{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}

-- |
-- Module      : Database.Relational.Projectable
-- Copyright   : 2013-2018 Kei Hibino
-- License     : BSD3
--
-- Maintainer  : ex8k.hibino@gmail.com
-- Stability   : experimental
-- Portability : unknown
--
-- This module defines operators on various projected records.
module Database.Relational.Projectable (
  -- * Projectable from SQL strings
  SqlContext (unsafeProjectSqlTerms), unsafeProjectSql',
  unsafeProjectSql,

  -- * Records of values
  value,
  valueTrue, valueFalse,
  values,
  nothing,

  -- * Placeholders
  PlaceHolders, unsafeAddPlaceHolders, unsafePlaceHolders,
  pwPlaceholder, placeholder', placeholder, unitPlaceHolder, unitPH,

  -- * Projectable into SQL strings
  unsafeShowSql', unsafeShowSql,

  -- * Operators
  (.=.), (.<.), (.<=.), (.>.), (.>=.), (.<>.),

  and', or', in',

  (.||.), (?||?), like, likeMaybe, like', likeMaybe',
  (.+.), (.-.), (.*.), (./.),
  (?+?), (?-?), (?*?), (?/?),

  isNothing, isJust, fromMaybe,
  not', exists,

  negate', fromIntegral', showNum,
  negateMaybe, fromIntegralMaybe, showNumMaybe,

  casesOrElse, casesOrElse',
  caseSearch, caseSearchMaybe, case', caseMaybe,

  SqlBinOp, unsafeBinOp, unsafeUniOp,

  -- * Terms for Window function types
  rank, denseRank, rowNumber, percentRank, cumeDist,

  -- * Zipping projections
  projectZip, (><),

  -- * 'Maybe' type projecitoins
  ProjectableMaybe (just, flattenMaybe),

  -- * Projection for nested 'Maybe's
  ProjectableFlattenMaybe (flatten),

  flattenPiMaybe,

  -- * Get narrower records
  (!), (?), (??), (?!), (?!?), (!??),

  -- * Aggregate functions
  unsafeAggregateOp,
  count,
  sum', sumMaybe, avg, avgMaybe,
  max', maxMaybe, min', minMaybe,
  every, any', some',
  ) where

import Prelude hiding (pi)

import Data.String (IsString)
import Data.Functor.ProductIsomorphic
  ((|$|), ProductIsoApplicative, pureP, (|*|), )

import Language.SQL.Keyword (Keyword)
import qualified Language.SQL.Keyword as SQL

import Database.Record
  (PersistableWidth, persistableWidth, PersistableRecordWidth,
   HasColumnConstraint, NotNull)
import Database.Record.Persistable (runPersistableRecordWidth)

import Database.Relational.Internal.ContextType (Flat, Exists, OverWindow)
import Database.Relational.Internal.String (StringSQL, stringSQL, showStringSQL)
import Database.Relational.SqlSyntax (Record, Predicate)
import qualified Database.Relational.SqlSyntax as Syntax

import Database.Relational.Pure ()
import Database.Relational.TupleInstances ()
import Database.Relational.Pi (Pi)
import Database.Relational.ProjectableClass
  (LiteralSQL, showLiteral, )
import Database.Relational.Record (RecordList)
import qualified Database.Relational.Record as Record
import Database.Relational.Projectable.Unsafe
  (SqlContext (..), OperatorContext, AggregatedContext, PlaceHolders (..))
import Database.Relational.Projectable.Instances ()


-- | Unsafely Project single SQL term.
unsafeProjectSql' :: SqlContext c => StringSQL -> Record c t
unsafeProjectSql' :: forall c t. SqlContext c => StringSQL -> Record c t
unsafeProjectSql' = forall c t. SqlContext c => [StringSQL] -> Record c t
unsafeProjectSqlTerms forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. a -> [a] -> [a]
:[])

-- | Unsafely Project single SQL string. String interface of 'unsafeProjectSql'''.
unsafeProjectSql :: SqlContext c => String -> Record c t
unsafeProjectSql :: forall c t. SqlContext c => String -> Record c t
unsafeProjectSql = forall c t. SqlContext c => StringSQL -> Record c t
unsafeProjectSql' forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> StringSQL
stringSQL

-- | Record with polymorphic phantom type of SQL null value. Semantics of comparing is unsafe.
nothing :: (OperatorContext c, SqlContext c, PersistableWidth a)
        => Record c (Maybe a)
nothing :: forall c a.
(OperatorContext c, SqlContext c, PersistableWidth a) =>
Record c (Maybe a)
nothing = forall c a.
SqlContext c =>
PersistableRecordWidth a -> Record c (Maybe a)
proxyWidth forall a. PersistableWidth a => PersistableRecordWidth a
persistableWidth
  where
    proxyWidth :: SqlContext c => PersistableRecordWidth a -> Record c (Maybe a)
    proxyWidth :: forall c a.
SqlContext c =>
PersistableRecordWidth a -> Record c (Maybe a)
proxyWidth PersistableRecordWidth a
w = forall c t. SqlContext c => [StringSQL] -> Record c t
unsafeProjectSqlTerms forall a b. (a -> b) -> a -> b
$ forall a. Int -> a -> [a]
replicate (forall a. PersistableRecordWidth a -> Int
runPersistableRecordWidth PersistableRecordWidth a
w) StringSQL
SQL.NULL

-- | Generate record with polymorphic type of SQL constant values from Haskell value.
value :: (LiteralSQL t, OperatorContext c) => t -> Record c t
value :: forall t c. (LiteralSQL t, OperatorContext c) => t -> Record c t
value = forall c t. SqlContext c => [StringSQL] -> Record c t
unsafeProjectSqlTerms forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. LiteralSQL a => a -> [StringSQL]
showLiteral

-- | Record with polymorphic type of SQL true value.
valueTrue  :: OperatorContext c => Record c (Maybe Bool)
valueTrue :: forall c. OperatorContext c => Record c (Maybe Bool)
valueTrue  =  forall (p :: * -> *) a. ProjectableMaybe p => p a -> p (Maybe a)
just forall a b. (a -> b) -> a -> b
$ forall t c. (LiteralSQL t, OperatorContext c) => t -> Record c t
value Bool
True

-- | Record with polymorphic type of SQL false value.
valueFalse :: OperatorContext c => Record c (Maybe Bool)
valueFalse :: forall c. OperatorContext c => Record c (Maybe Bool)
valueFalse =  forall (p :: * -> *) a. ProjectableMaybe p => p a -> p (Maybe a)
just forall a b. (a -> b) -> a -> b
$ forall t c. (LiteralSQL t, OperatorContext c) => t -> Record c t
value Bool
False

-- | RecordList with polymorphic type of SQL set value from Haskell list.
values :: (LiteralSQL t, OperatorContext c) => [t] -> RecordList (Record c) t
values :: forall t c.
(LiteralSQL t, OperatorContext c) =>
[t] -> RecordList (Record c) t
values =  forall (p :: * -> *) t. [p t] -> RecordList p t
Record.list forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall t c. (LiteralSQL t, OperatorContext c) => t -> Record c t
value


-- | Unsafely generate SQL expression term from record object.
unsafeShowSql' :: Record c a -> StringSQL
unsafeShowSql' :: forall c a. Record c a -> StringSQL
unsafeShowSql' = forall c a. Record c a -> StringSQL
Record.unsafeStringSql

-- | Unsafely generate SQL expression string from record object.
--   String interface of 'unsafeShowSql''.
unsafeShowSql :: Record c a    -- ^ Source record object
              -> String -- ^ Result SQL expression string.
unsafeShowSql :: forall c a. Record c a -> String
unsafeShowSql =  StringSQL -> String
showStringSQL forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c a. Record c a -> StringSQL
unsafeShowSql'


-- | Binary operator type for SQL String.
type SqlBinOp = Keyword -> Keyword -> Keyword

-- | Unsafely make unary operator for records from SQL keyword.
unsafeUniOp :: SqlContext c2
            => (Keyword -> Keyword) -> Record c1 a -> Record c2 b
unsafeUniOp :: forall c2 c1 a b.
SqlContext c2 =>
(StringSQL -> StringSQL) -> Record c1 a -> Record c2 b
unsafeUniOp StringSQL -> StringSQL
u = forall c t. SqlContext c => StringSQL -> Record c t
unsafeProjectSql' forall b c a. (b -> c) -> (a -> b) -> a -> c
. StringSQL -> StringSQL
u forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c a. Record c a -> StringSQL
unsafeShowSql'

unsafeFlatUniOp :: SqlContext c
                => Keyword -> Record c a -> Record c b
unsafeFlatUniOp :: forall c a b. SqlContext c => StringSQL -> Record c a -> Record c b
unsafeFlatUniOp StringSQL
kw = forall c2 c1 a b.
SqlContext c2 =>
(StringSQL -> StringSQL) -> Record c1 a -> Record c2 b
unsafeUniOp (StringSQL -> StringSQL
SQL.paren forall b c a. (b -> c) -> (a -> b) -> a -> c
. StringSQL -> StringSQL -> StringSQL
SQL.defineUniOp StringSQL
kw)

-- | Unsafely make binary operator for records from string binary operator.
unsafeBinOp :: SqlContext k
            => SqlBinOp
            -> Record k a -> Record k b -> Record k c
unsafeBinOp :: forall k a b c.
SqlContext k =>
(StringSQL -> StringSQL -> StringSQL)
-> Record k a -> Record k b -> Record k c
unsafeBinOp StringSQL -> StringSQL -> StringSQL
op Record k a
a Record k b
b = forall c t. SqlContext c => StringSQL -> Record c t
unsafeProjectSql' forall b c a. (b -> c) -> (a -> b) -> a -> c
. StringSQL -> StringSQL
SQL.paren forall a b. (a -> b) -> a -> b
$
                     StringSQL -> StringSQL -> StringSQL
op (forall c a. Record c a -> StringSQL
unsafeShowSql' Record k a
a) (forall c a. Record c a -> StringSQL
unsafeShowSql' Record k b
b)

-- | Unsafely make binary operator to compare records from string binary operator.
compareBinOp :: SqlContext c
             => SqlBinOp
             -> Record c a -> Record c a -> Record c (Maybe Bool)
compareBinOp :: forall c a.
SqlContext c =>
(StringSQL -> StringSQL -> StringSQL)
-> Record c a -> Record c a -> Record c (Maybe Bool)
compareBinOp =  forall k a b c.
SqlContext k =>
(StringSQL -> StringSQL -> StringSQL)
-> Record k a -> Record k b -> Record k c
unsafeBinOp

-- | Unsafely make numrical binary operator for records from string binary operator.
monoBinOp :: SqlContext c
          => SqlBinOp
          -> Record c a -> Record c a -> Record c a
monoBinOp :: forall c a.
SqlContext c =>
(StringSQL -> StringSQL -> StringSQL)
-> Record c a -> Record c a -> Record c a
monoBinOp =  forall k a b c.
SqlContext k =>
(StringSQL -> StringSQL -> StringSQL)
-> Record k a -> Record k b -> Record k c
unsafeBinOp


-- | Compare operator corresponding SQL /=/ .
(.=.)  :: OperatorContext c
       => Record c ft -> Record c ft -> Record c (Maybe Bool)
.=. :: forall c ft.
OperatorContext c =>
Record c ft -> Record c ft -> Record c (Maybe Bool)
(.=.)  =  forall c a.
SqlContext c =>
(StringSQL -> StringSQL -> StringSQL)
-> Record c a -> Record c a -> Record c (Maybe Bool)
compareBinOp StringSQL -> StringSQL -> StringSQL
(SQL..=.)

-- | Compare operator corresponding SQL /</ .
(.<.)  :: OperatorContext c
       => Record c ft -> Record c ft -> Record c (Maybe Bool)
.<. :: forall c ft.
OperatorContext c =>
Record c ft -> Record c ft -> Record c (Maybe Bool)
(.<.)  =  forall c a.
SqlContext c =>
(StringSQL -> StringSQL -> StringSQL)
-> Record c a -> Record c a -> Record c (Maybe Bool)
compareBinOp StringSQL -> StringSQL -> StringSQL
(SQL..<.)

-- | Compare operator corresponding SQL /<=/ .
(.<=.)  :: OperatorContext c
        => Record c ft -> Record c ft -> Record c (Maybe Bool)
.<=. :: forall c ft.
OperatorContext c =>
Record c ft -> Record c ft -> Record c (Maybe Bool)
(.<=.)  =  forall c a.
SqlContext c =>
(StringSQL -> StringSQL -> StringSQL)
-> Record c a -> Record c a -> Record c (Maybe Bool)
compareBinOp StringSQL -> StringSQL -> StringSQL
(SQL..<=.)

-- | Compare operator corresponding SQL />/ .
(.>.)  :: OperatorContext c
       => Record c ft -> Record c ft -> Record c (Maybe Bool)
.>. :: forall c ft.
OperatorContext c =>
Record c ft -> Record c ft -> Record c (Maybe Bool)
(.>.)  =  forall c a.
SqlContext c =>
(StringSQL -> StringSQL -> StringSQL)
-> Record c a -> Record c a -> Record c (Maybe Bool)
compareBinOp StringSQL -> StringSQL -> StringSQL
(SQL..>.)

-- | Compare operator corresponding SQL />=/ .
(.>=.)  :: OperatorContext c
        => Record c ft -> Record c ft -> Record c (Maybe Bool)
.>=. :: forall c ft.
OperatorContext c =>
Record c ft -> Record c ft -> Record c (Maybe Bool)
(.>=.)  =  forall c a.
SqlContext c =>
(StringSQL -> StringSQL -> StringSQL)
-> Record c a -> Record c a -> Record c (Maybe Bool)
compareBinOp StringSQL -> StringSQL -> StringSQL
(SQL..>=.)

-- | Compare operator corresponding SQL /<>/ .
(.<>.) :: OperatorContext c
       => Record c ft -> Record c ft -> Record c (Maybe Bool)
.<>. :: forall c ft.
OperatorContext c =>
Record c ft -> Record c ft -> Record c (Maybe Bool)
(.<>.) =  forall c a.
SqlContext c =>
(StringSQL -> StringSQL -> StringSQL)
-> Record c a -> Record c a -> Record c (Maybe Bool)
compareBinOp StringSQL -> StringSQL -> StringSQL
(SQL..<>.)

-- | Logical operator corresponding SQL /AND/ .
and' :: OperatorContext c
     => Record c (Maybe Bool) -> Record c (Maybe Bool) -> Record c (Maybe Bool)
and' :: forall c.
OperatorContext c =>
Record c (Maybe Bool)
-> Record c (Maybe Bool) -> Record c (Maybe Bool)
and' = forall c a.
SqlContext c =>
(StringSQL -> StringSQL -> StringSQL)
-> Record c a -> Record c a -> Record c a
monoBinOp StringSQL -> StringSQL -> StringSQL
SQL.and

-- | Logical operator corresponding SQL /OR/ .
or' :: OperatorContext c
    => Record c (Maybe Bool) -> Record c (Maybe Bool) -> Record c (Maybe Bool)
or' :: forall c.
OperatorContext c =>
Record c (Maybe Bool)
-> Record c (Maybe Bool) -> Record c (Maybe Bool)
or'  = forall c a.
SqlContext c =>
(StringSQL -> StringSQL -> StringSQL)
-> Record c a -> Record c a -> Record c a
monoBinOp StringSQL -> StringSQL -> StringSQL
SQL.or

-- | Logical operator corresponding SQL /NOT/ .
not' :: OperatorContext c
     => Record c (Maybe Bool) -> Record c (Maybe Bool)
not' :: forall c.
OperatorContext c =>
Record c (Maybe Bool) -> Record c (Maybe Bool)
not' =  forall c a b. SqlContext c => StringSQL -> Record c a -> Record c b
unsafeFlatUniOp StringSQL
SQL.NOT

-- | Logical operator corresponding SQL /EXISTS/ .
exists :: OperatorContext c
       => RecordList (Record Exists) r -> Record c (Maybe Bool)
exists :: forall c r.
OperatorContext c =>
RecordList (Record Exists) r -> Record c (Maybe Bool)
exists =  forall c t. SqlContext c => StringSQL -> Record c t
unsafeProjectSql' forall b c a. (b -> c) -> (a -> b) -> a -> c
. StringSQL -> StringSQL
SQL.paren forall b c a. (b -> c) -> (a -> b) -> a -> c
. StringSQL -> StringSQL -> StringSQL
SQL.defineUniOp StringSQL
SQL.EXISTS
          forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (p :: * -> *) t.
(p t -> StringSQL) -> RecordList p t -> StringSQL
Record.unsafeStringSqlList forall c a. Record c a -> StringSQL
unsafeShowSql'

-- | Concatenate operator corresponding SQL /||/ .
(.||.) :: OperatorContext c
       => Record c a -> Record c a -> Record c a
.||. :: forall c a.
OperatorContext c =>
Record c a -> Record c a -> Record c a
(.||.) =  forall k a b c.
SqlContext k =>
(StringSQL -> StringSQL -> StringSQL)
-> Record k a -> Record k b -> Record k c
unsafeBinOp StringSQL -> StringSQL -> StringSQL
(SQL..||.)

-- | Concatenate operator corresponding SQL /||/ . Maybe type version.
(?||?) :: (OperatorContext c, IsString a)
       => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a)
?||? :: forall c a.
(OperatorContext c, IsString a) =>
Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a)
(?||?) =  forall k a b c.
SqlContext k =>
(StringSQL -> StringSQL -> StringSQL)
-> Record k a -> Record k b -> Record k c
unsafeBinOp StringSQL -> StringSQL -> StringSQL
(SQL..||.)

unsafeLike :: OperatorContext c
           => Record c a -> Record c b -> Record c (Maybe Bool)
unsafeLike :: forall c a b.
OperatorContext c =>
Record c a -> Record c b -> Record c (Maybe Bool)
unsafeLike = forall k a b c.
SqlContext k =>
(StringSQL -> StringSQL -> StringSQL)
-> Record k a -> Record k b -> Record k c
unsafeBinOp (StringSQL -> StringSQL -> StringSQL -> StringSQL
SQL.defineBinOp StringSQL
SQL.LIKE)

-- | String-compare operator corresponding SQL /LIKE/ .
like' :: (OperatorContext c, IsString a)
      => Record c a -> Record c a -> Record c (Maybe Bool)
Record c a
x like' :: forall c a.
(OperatorContext c, IsString a) =>
Record c a -> Record c a -> Record c (Maybe Bool)
`like'` Record c a
y = Record c a
x forall c a b.
OperatorContext c =>
Record c a -> Record c b -> Record c (Maybe Bool)
`unsafeLike` Record c a
y

-- | String-compare operator corresponding SQL /LIKE/ .
likeMaybe' :: (OperatorContext c, IsString a)
           => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe Bool)
Record c (Maybe a)
x likeMaybe' :: forall c a.
(OperatorContext c, IsString a) =>
Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe Bool)
`likeMaybe'` Record c (Maybe a)
y = Record c (Maybe a)
x forall c a b.
OperatorContext c =>
Record c a -> Record c b -> Record c (Maybe Bool)
`unsafeLike` Record c (Maybe a)
y

-- | String-compare operator corresponding SQL /LIKE/ .
like :: (OperatorContext c, IsString a, LiteralSQL a)
       => Record c a -> a -> Record c (Maybe Bool)
Record c a
x like :: forall c a.
(OperatorContext c, IsString a, LiteralSQL a) =>
Record c a -> a -> Record c (Maybe Bool)
`like` a
a = Record c a
x forall c a.
(OperatorContext c, IsString a) =>
Record c a -> Record c a -> Record c (Maybe Bool)
`like'` forall t c. (LiteralSQL t, OperatorContext c) => t -> Record c t
value a
a

-- | String-compare operator corresponding SQL /LIKE/ . Maybe type version.
likeMaybe :: (OperatorContext c, IsString a, LiteralSQL a)
          => Record c (Maybe a) -> a -> Record c (Maybe Bool)
Record c (Maybe a)
x likeMaybe :: forall c a.
(OperatorContext c, IsString a, LiteralSQL a) =>
Record c (Maybe a) -> a -> Record c (Maybe Bool)
`likeMaybe` a
a = Record c (Maybe a)
x forall c a b.
OperatorContext c =>
Record c a -> Record c b -> Record c (Maybe Bool)
`unsafeLike` forall t c. (LiteralSQL t, OperatorContext c) => t -> Record c t
value a
a

-- | Unsafely make number binary operator for records from SQL operator string.
monoBinOp' :: SqlContext c
           => Keyword -> Record c a -> Record c a -> Record c a
monoBinOp' :: forall c a.
SqlContext c =>
StringSQL -> Record c a -> Record c a -> Record c a
monoBinOp' = forall c a.
SqlContext c =>
(StringSQL -> StringSQL -> StringSQL)
-> Record c a -> Record c a -> Record c a
monoBinOp forall b c a. (b -> c) -> (a -> b) -> a -> c
. StringSQL -> StringSQL -> StringSQL -> StringSQL
SQL.defineBinOp

-- | Number operator corresponding SQL /+/ .
(.+.) :: (OperatorContext c, Num a)
      => Record c a -> Record c a -> Record c a
.+. :: forall c a.
(OperatorContext c, Num a) =>
Record c a -> Record c a -> Record c a
(.+.) =  forall c a.
SqlContext c =>
StringSQL -> Record c a -> Record c a -> Record c a
monoBinOp' StringSQL
"+"

-- | Number operator corresponding SQL /-/ .
(.-.) :: (OperatorContext c, Num a)
      => Record c a -> Record c a -> Record c a
.-. :: forall c a.
(OperatorContext c, Num a) =>
Record c a -> Record c a -> Record c a
(.-.) =  forall c a.
SqlContext c =>
StringSQL -> Record c a -> Record c a -> Record c a
monoBinOp' StringSQL
"-"

-- | Number operator corresponding SQL /// .
(./.) :: (OperatorContext c, Num a)
      => Record c a -> Record c a -> Record c a
./. :: forall c a.
(OperatorContext c, Num a) =>
Record c a -> Record c a -> Record c a
(./.) =  forall c a.
SqlContext c =>
StringSQL -> Record c a -> Record c a -> Record c a
monoBinOp' StringSQL
"/"

-- | Number operator corresponding SQL /*/ .
(.*.) :: (OperatorContext c, Num a)
      => Record c a -> Record c a -> Record c a
.*. :: forall c a.
(OperatorContext c, Num a) =>
Record c a -> Record c a -> Record c a
(.*.) =  forall c a.
SqlContext c =>
StringSQL -> Record c a -> Record c a -> Record c a
monoBinOp' StringSQL
"*"

-- | Number negate uni-operator corresponding SQL /-/.
negate' :: (OperatorContext c, Num a)
        => Record c a -> Record c a
negate' :: forall c a. (OperatorContext c, Num a) => Record c a -> Record c a
negate' =  forall c a b. SqlContext c => StringSQL -> Record c a -> Record c b
unsafeFlatUniOp forall a b. (a -> b) -> a -> b
$ String -> StringSQL
SQL.word String
"-"

unsafeCastProjectable :: SqlContext c
                      => Record c a -> Record c b
unsafeCastProjectable :: forall c a b. SqlContext c => Record c a -> Record c b
unsafeCastProjectable = forall c t. Tuple -> Record c t
Syntax.record forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c t. Record c t -> Tuple
Syntax.untypeRecord

-- | Number fromIntegral uni-operator.
fromIntegral' :: (SqlContext c, Integral a, Num b)
              => Record c a -> Record c b
fromIntegral' :: forall c a b.
(SqlContext c, Integral a, Num b) =>
Record c a -> Record c b
fromIntegral' =  forall c a b. SqlContext c => Record c a -> Record c b
unsafeCastProjectable

-- | Unsafely show number into string-like type in records.
showNum :: (SqlContext c, Num a, IsString b)
        => Record c a -> Record c b
showNum :: forall c a b.
(SqlContext c, Num a, IsString b) =>
Record c a -> Record c b
showNum =  forall c a b. SqlContext c => Record c a -> Record c b
unsafeCastProjectable

-- | Number operator corresponding SQL /+/ .
(?+?) :: (OperatorContext c, Num a)
      => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a)
?+? :: forall c a.
(OperatorContext c, Num a) =>
Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a)
(?+?) =  forall c a.
SqlContext c =>
StringSQL -> Record c a -> Record c a -> Record c a
monoBinOp' StringSQL
"+"

-- | Number operator corresponding SQL /-/ .
(?-?) :: (OperatorContext c, Num a)
      => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a)
?-? :: forall c a.
(OperatorContext c, Num a) =>
Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a)
(?-?) =  forall c a.
SqlContext c =>
StringSQL -> Record c a -> Record c a -> Record c a
monoBinOp' StringSQL
"-"

-- | Number operator corresponding SQL /// .
(?/?) :: (OperatorContext c, Num a)
      => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a)
?/? :: forall c a.
(OperatorContext c, Num a) =>
Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a)
(?/?) =  forall c a.
SqlContext c =>
StringSQL -> Record c a -> Record c a -> Record c a
monoBinOp' StringSQL
"/"

-- | Number operator corresponding SQL /*/ .
(?*?) :: (OperatorContext c, Num a)
      => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a)
?*? :: forall c a.
(OperatorContext c, Num a) =>
Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a)
(?*?) =  forall c a.
SqlContext c =>
StringSQL -> Record c a -> Record c a -> Record c a
monoBinOp' StringSQL
"*"

-- | Number negate uni-operator corresponding SQL /-/.
negateMaybe :: (OperatorContext c, Num a)
            => Record c (Maybe a) -> Record c (Maybe a)
negateMaybe :: forall c a.
(OperatorContext c, Num a) =>
Record c (Maybe a) -> Record c (Maybe a)
negateMaybe =  forall c a b. SqlContext c => StringSQL -> Record c a -> Record c b
unsafeFlatUniOp forall a b. (a -> b) -> a -> b
$ String -> StringSQL
SQL.word String
"-"

-- | Number fromIntegral uni-operator.
fromIntegralMaybe :: (SqlContext c, Integral a, Num b)
                  => Record c (Maybe a) -> Record c (Maybe b)
fromIntegralMaybe :: forall c a b.
(SqlContext c, Integral a, Num b) =>
Record c (Maybe a) -> Record c (Maybe b)
fromIntegralMaybe =  forall c a b. SqlContext c => Record c a -> Record c b
unsafeCastProjectable

-- | Unsafely show number into string-like type in records.
showNumMaybe :: (SqlContext c, Num a, IsString b)
             => Record c (Maybe a) -> Record c (Maybe b)
showNumMaybe :: forall c a b.
(SqlContext c, Num a, IsString b) =>
Record c (Maybe a) -> Record c (Maybe b)
showNumMaybe = forall c a b. SqlContext c => Record c a -> Record c b
unsafeCastProjectable

-- | Search case operator correnponding SQL search /CASE/.
--   Like, /CASE WHEN p0 THEN a WHEN p1 THEN b ... ELSE c END/
caseSearch :: OperatorContext c
           => [(Predicate c, Record c a)] -- ^ Each when clauses
           -> Record c a                            -- ^ Else result record
           -> Record c a                            -- ^ Result record
caseSearch :: forall c a.
OperatorContext c =>
[(Predicate c, Record c a)] -> Record c a -> Record c a
caseSearch = forall c a. [(Predicate c, Record c a)] -> Record c a -> Record c a
Syntax.caseSearch

-- | Same as 'caseSearch', but you can write like <when list> `casesOrElse` <else clause>.
casesOrElse :: OperatorContext c
            => [(Predicate c, Record c a)] -- ^ Each when clauses
            -> Record c a                            -- ^ Else result record
            -> Record c a                            -- ^ Result record
casesOrElse :: forall c a.
OperatorContext c =>
[(Predicate c, Record c a)] -> Record c a -> Record c a
casesOrElse = forall c a.
OperatorContext c =>
[(Predicate c, Record c a)] -> Record c a -> Record c a
caseSearch

-- | Null default version of 'caseSearch'.
caseSearchMaybe :: (OperatorContext c {- (Record c) is always ProjectableMaybe -}, PersistableWidth a)
                => [(Predicate c, Record c (Maybe a))] -- ^ Each when clauses
                -> Record c (Maybe a)                            -- ^ Result record
caseSearchMaybe :: forall c a.
(OperatorContext c, PersistableWidth a) =>
[(Predicate c, Record c (Maybe a))] -> Record c (Maybe a)
caseSearchMaybe [(Predicate c, Record c (Maybe a))]
cs = forall c a.
OperatorContext c =>
[(Predicate c, Record c a)] -> Record c a -> Record c a
caseSearch [(Predicate c, Record c (Maybe a))]
cs forall c a.
(OperatorContext c, SqlContext c, PersistableWidth a) =>
Record c (Maybe a)
nothing

-- | Simple case operator correnponding SQL simple /CASE/.
--   Like, /CASE x WHEN v THEN a WHEN w THEN b ... ELSE c END/
case' :: OperatorContext c
      => Record c a                 -- ^ Record value to match
      -> [(Record c a, Record c b)] -- ^ Each when clauses
      -> Record c b                 -- ^ Else result record
      -> Record c b                 -- ^ Result record
case' :: forall c a b.
OperatorContext c =>
Record c a
-> [(Record c a, Record c b)] -> Record c b -> Record c b
case' = forall c a b.
Record c a
-> [(Record c a, Record c b)] -> Record c b -> Record c b
Syntax.case'

-- | Uncurry version of 'case'', and you can write like ... `casesOrElse'` <else clause>.
casesOrElse' :: OperatorContext c
             => (Record c a, [(Record c a, Record c b)]) -- ^ Record value to match and each when clauses list
             -> Record c b                               -- ^ Else result record
             -> Record c b                               -- ^ Result record
casesOrElse' :: forall c a b.
OperatorContext c =>
(Record c a, [(Record c a, Record c b)])
-> Record c b -> Record c b
casesOrElse' =  forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry forall c a b.
OperatorContext c =>
Record c a
-> [(Record c a, Record c b)] -> Record c b -> Record c b
case'

-- | Null default version of 'case''.
caseMaybe :: (OperatorContext c {- (Record c) is always ProjectableMaybe -}, PersistableWidth b)
          => Record c a                         -- ^ Record value to match
          -> [(Record c a, Record c (Maybe b))] -- ^ Each when clauses
          -> Record c (Maybe b)                 -- ^ Result record
caseMaybe :: forall c b a.
(OperatorContext c, PersistableWidth b) =>
Record c a
-> [(Record c a, Record c (Maybe b))] -> Record c (Maybe b)
caseMaybe Record c a
v [(Record c a, Record c (Maybe b))]
cs = forall c a b.
OperatorContext c =>
Record c a
-> [(Record c a, Record c b)] -> Record c b -> Record c b
case' Record c a
v [(Record c a, Record c (Maybe b))]
cs forall c a.
(OperatorContext c, SqlContext c, PersistableWidth a) =>
Record c (Maybe a)
nothing

-- | Binary operator corresponding SQL /IN/ .
in' :: OperatorContext c
    => Record c t -> RecordList (Record c) t -> Record c (Maybe Bool)
in' :: forall c t.
OperatorContext c =>
Record c t -> RecordList (Record c) t -> Record c (Maybe Bool)
in' Record c t
a RecordList (Record c) t
lp = forall c t. SqlContext c => StringSQL -> Record c t
unsafeProjectSql' forall b c a. (b -> c) -> (a -> b) -> a -> c
. StringSQL -> StringSQL
SQL.paren
           forall a b. (a -> b) -> a -> b
$ StringSQL -> StringSQL -> StringSQL
SQL.in' (forall c a. Record c a -> StringSQL
unsafeShowSql' Record c t
a) (forall (p :: * -> *) t.
(p t -> StringSQL) -> RecordList p t -> StringSQL
Record.unsafeStringSqlList forall c a. Record c a -> StringSQL
unsafeShowSql' RecordList (Record c) t
lp)

-- | Operator corresponding SQL /IS NULL/ , and extended against record types.
isNothing :: (OperatorContext c, HasColumnConstraint NotNull r)
          => Record c (Maybe r) -> Predicate c
isNothing :: forall c r.
(OperatorContext c, HasColumnConstraint NotNull r) =>
Record c (Maybe r) -> Predicate c
isNothing Record c (Maybe r)
mr = forall c t. SqlContext c => StringSQL -> Record c t
unsafeProjectSql' forall a b. (a -> b) -> a -> b
$
               StringSQL -> StringSQL
SQL.paren forall a b. (a -> b) -> a -> b
$ (StringSQL -> StringSQL -> StringSQL -> StringSQL
SQL.defineBinOp StringSQL
SQL.IS)
               (forall r c.
HasColumnConstraint NotNull r =>
Record c (Maybe r) -> StringSQL
Record.unsafeStringSqlNotNullMaybe Record c (Maybe r)
mr) StringSQL
SQL.NULL

-- | Operator corresponding SQL /NOT (... IS NULL)/ , and extended against record type.
isJust :: (OperatorContext c, HasColumnConstraint NotNull r)
          => Record c (Maybe r) -> Predicate c
isJust :: forall c r.
(OperatorContext c, HasColumnConstraint NotNull r) =>
Record c (Maybe r) -> Predicate c
isJust =  forall c.
OperatorContext c =>
Record c (Maybe Bool) -> Record c (Maybe Bool)
not' forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c r.
(OperatorContext c, HasColumnConstraint NotNull r) =>
Record c (Maybe r) -> Predicate c
isNothing

-- | Operator from maybe type using record extended 'isNull'.
fromMaybe :: (OperatorContext c, HasColumnConstraint NotNull r)
          => Record c r -> Record c (Maybe r) -> Record c r
fromMaybe :: forall c r.
(OperatorContext c, HasColumnConstraint NotNull r) =>
Record c r -> Record c (Maybe r) -> Record c r
fromMaybe Record c r
d Record c (Maybe r)
p = [ (forall c r.
(OperatorContext c, HasColumnConstraint NotNull r) =>
Record c (Maybe r) -> Predicate c
isNothing Record c (Maybe r)
p, Record c r
d) ] forall c a.
OperatorContext c =>
[(Predicate c, Record c a)] -> Record c a -> Record c a
`casesOrElse` forall c a b. SqlContext c => Record c a -> Record c b
unsafeCastProjectable Record c (Maybe r)
p

unsafeUniTermFunction :: SqlContext c => Keyword -> Record c t
unsafeUniTermFunction :: forall c t. SqlContext c => StringSQL -> Record c t
unsafeUniTermFunction =  forall c t. SqlContext c => StringSQL -> Record c t
unsafeProjectSql' forall b c a. (b -> c) -> (a -> b) -> a -> c
. (StringSQL -> StringSQL -> StringSQL
SQL.<++> String -> StringSQL
stringSQL String
"()")

-- | /RANK()/ term.
rank :: Integral a => Record OverWindow a
rank :: forall a. Integral a => Record OverWindow a
rank =  forall c t. SqlContext c => StringSQL -> Record c t
unsafeUniTermFunction StringSQL
SQL.RANK

-- | /DENSE_RANK()/ term.
denseRank :: Integral a => Record OverWindow a
denseRank :: forall a. Integral a => Record OverWindow a
denseRank =  forall c t. SqlContext c => StringSQL -> Record c t
unsafeUniTermFunction StringSQL
SQL.DENSE_RANK

-- | /ROW_NUMBER()/ term.
rowNumber :: Integral a => Record OverWindow a
rowNumber :: forall a. Integral a => Record OverWindow a
rowNumber =  forall c t. SqlContext c => StringSQL -> Record c t
unsafeUniTermFunction StringSQL
SQL.ROW_NUMBER

-- | /PERCENT_RANK()/ term.
percentRank :: Record OverWindow Double
percentRank :: Record OverWindow Double
percentRank =  forall c t. SqlContext c => StringSQL -> Record c t
unsafeUniTermFunction StringSQL
SQL.PERCENT_RANK

-- | /CUME_DIST()/ term.
cumeDist :: Record OverWindow Double
cumeDist :: Record OverWindow Double
cumeDist =  forall c t. SqlContext c => StringSQL -> Record c t
unsafeUniTermFunction StringSQL
SQL.CUME_DIST

-- | Unsafely add placeholder parameter to queries.
unsafeAddPlaceHolders :: Functor f => f a -> f (PlaceHolders p, a)
unsafeAddPlaceHolders :: forall (f :: * -> *) a p. Functor f => f a -> f (PlaceHolders p, a)
unsafeAddPlaceHolders =  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((,) forall p. PlaceHolders p
PlaceHolders)

-- | Unsafely get placeholder parameter
unsafePlaceHolders :: PlaceHolders p
unsafePlaceHolders :: forall p. PlaceHolders p
unsafePlaceHolders =  forall p. PlaceHolders p
PlaceHolders

-- | No placeholder semantics
unitPlaceHolder :: PlaceHolders ()
unitPlaceHolder :: PlaceHolders ()
unitPlaceHolder = forall (f :: * -> *) a.
(ProductIsoApplicative f, ProductConstructor a) =>
a -> f a
pureP ()

-- | No placeholder semantics. Same as `unitPlaceHolder`
unitPH :: PlaceHolders ()
unitPH :: PlaceHolders ()
unitPH = forall (f :: * -> *) a.
(ProductIsoApplicative f, ProductConstructor a) =>
a -> f a
pureP ()

-- | Unsafely cast placeholder parameter type.
unsafeCastPlaceHolders :: PlaceHolders a -> PlaceHolders b
unsafeCastPlaceHolders :: forall a b. PlaceHolders a -> PlaceHolders b
unsafeCastPlaceHolders PlaceHolders a
PlaceHolders = forall p. PlaceHolders p
PlaceHolders

-- | Provide scoped placeholder from width and return its parameter object.
pwPlaceholder :: SqlContext c
              => PersistableRecordWidth a
              -> (Record c a -> b)
              -> (PlaceHolders a, b)
pwPlaceholder :: forall c a b.
SqlContext c =>
PersistableRecordWidth a
-> (Record c a -> b) -> (PlaceHolders a, b)
pwPlaceholder PersistableRecordWidth a
pw Record c a -> b
f = (forall p. PlaceHolders p
PlaceHolders, Record c a -> b
f forall a b. (a -> b) -> a -> b
$ forall c a. SqlContext c => PersistableRecordWidth a -> Record c a
projectPlaceHolder PersistableRecordWidth a
pw)
  where
    projectPlaceHolder :: SqlContext c
                       => PersistableRecordWidth a
                       -> Record c a
    projectPlaceHolder :: forall c a. SqlContext c => PersistableRecordWidth a -> Record c a
projectPlaceHolder = forall c t. SqlContext c => [StringSQL] -> Record c t
unsafeProjectSqlTerms forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. Int -> a -> [a]
`replicate` StringSQL
"?") forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. PersistableRecordWidth a -> Int
runPersistableRecordWidth

-- | Provide scoped placeholder and return its parameter object.
placeholder' :: (PersistableWidth t, SqlContext c) => (Record c t -> a) ->  (PlaceHolders t, a)
placeholder' :: forall t c a.
(PersistableWidth t, SqlContext c) =>
(Record c t -> a) -> (PlaceHolders t, a)
placeholder' = forall c a b.
SqlContext c =>
PersistableRecordWidth a
-> (Record c a -> b) -> (PlaceHolders a, b)
pwPlaceholder forall a. PersistableWidth a => PersistableRecordWidth a
persistableWidth

-- | Provide scoped placeholder and return its parameter object. Monadic version.
placeholder :: (PersistableWidth t, SqlContext c, Monad m) => (Record c t -> m a) -> m (PlaceHolders t, a)
placeholder :: forall t c (m :: * -> *) a.
(PersistableWidth t, SqlContext c, Monad m) =>
(Record c t -> m a) -> m (PlaceHolders t, a)
placeholder Record c t -> m a
f = do
  let (PlaceHolders t
ph, m a
ma) = forall t c a.
(PersistableWidth t, SqlContext c) =>
(Record c t -> a) -> (PlaceHolders t, a)
placeholder' Record c t -> m a
f
  a
a <- m a
ma
  forall (m :: * -> *) a. Monad m => a -> m a
return (PlaceHolders t
ph, a
a)


-- | Zipping projections.
projectZip :: ProductIsoApplicative p => p a -> p b -> p (a, b)
projectZip :: forall (p :: * -> *) a b.
ProductIsoApplicative p =>
p a -> p b -> p (a, b)
projectZip p a
pa p b
pb = (,) forall (f :: * -> *) a b.
(ProductIsoFunctor f, ProductConstructor (a -> b)) =>
(a -> b) -> f a -> f b
|$| p a
pa forall (f :: * -> *) a b.
ProductIsoApplicative f =>
f (a -> b) -> f a -> f b
|*| p b
pb

-- | Binary operator the same as 'projectZip'.
(><) :: ProductIsoApplicative p => p a -> p b -> p (a, b)
>< :: forall (p :: * -> *) a b.
ProductIsoApplicative p =>
p a -> p b -> p (a, b)
(><) = forall (p :: * -> *) a b.
ProductIsoApplicative p =>
p a -> p b -> p (a, b)
projectZip

-- | Interface to control 'Maybe' of phantom type in records.
class ProjectableMaybe p where
  -- | Cast record phantom type into 'Maybe'.
  just :: p a -> p (Maybe a)
  -- | Compose nested 'Maybe' phantom type on record.
  flattenMaybe :: p (Maybe (Maybe a)) -> p (Maybe a)

-- | Control phantom 'Maybe' type in placeholder parameters.
instance ProjectableMaybe PlaceHolders where
  just :: forall a. PlaceHolders a -> PlaceHolders (Maybe a)
just         = forall a b. PlaceHolders a -> PlaceHolders b
unsafeCastPlaceHolders
  flattenMaybe :: forall a. PlaceHolders (Maybe (Maybe a)) -> PlaceHolders (Maybe a)
flattenMaybe = forall a b. PlaceHolders a -> PlaceHolders b
unsafeCastPlaceHolders

-- | Control phantom 'Maybe' type in record type 'Record'.
instance ProjectableMaybe (Record c) where
  just :: forall a. Record c a -> Record c (Maybe a)
just         = forall c a. Record c a -> Record c (Maybe a)
Record.just
  flattenMaybe :: forall a. Record c (Maybe (Maybe a)) -> Record c (Maybe a)
flattenMaybe = forall c a. Record c (Maybe (Maybe a)) -> Record c (Maybe a)
Record.flattenMaybe


-- | Unsafely make aggregation uni-operator from SQL keyword.
unsafeAggregateOp :: (AggregatedContext ac, SqlContext ac)
                  => SQL.Keyword -> Record Flat a -> Record ac b
unsafeAggregateOp :: forall ac a b.
(AggregatedContext ac, SqlContext ac) =>
StringSQL -> Record Flat a -> Record ac b
unsafeAggregateOp StringSQL
op = forall c2 c1 a b.
SqlContext c2 =>
(StringSQL -> StringSQL) -> Record c1 a -> Record c2 b
unsafeUniOp ((StringSQL
op StringSQL -> StringSQL -> StringSQL
SQL.<++>) forall b c a. (b -> c) -> (a -> b) -> a -> c
. StringSQL -> StringSQL
SQL.paren)

-- | Aggregation function COUNT.
count :: (Integral b, AggregatedContext ac, SqlContext ac)
      => Record Flat a -> Record ac b
count :: forall b ac a.
(Integral b, AggregatedContext ac, SqlContext ac) =>
Record Flat a -> Record ac b
count =  forall ac a b.
(AggregatedContext ac, SqlContext ac) =>
StringSQL -> Record Flat a -> Record ac b
unsafeAggregateOp StringSQL
SQL.COUNT

-- | Aggregation function SUM.
sumMaybe :: (Num a, AggregatedContext ac, SqlContext ac)
         => Record Flat (Maybe a) -> Record ac (Maybe a)
sumMaybe :: forall a ac.
(Num a, AggregatedContext ac, SqlContext ac) =>
Record Flat (Maybe a) -> Record ac (Maybe a)
sumMaybe  =  forall ac a b.
(AggregatedContext ac, SqlContext ac) =>
StringSQL -> Record Flat a -> Record ac b
unsafeAggregateOp StringSQL
SQL.SUM

-- | Aggregation function SUM.
sum' :: (Num a, AggregatedContext ac, SqlContext ac)
     => Record Flat a -> Record ac (Maybe a)
sum' :: forall a ac.
(Num a, AggregatedContext ac, SqlContext ac) =>
Record Flat a -> Record ac (Maybe a)
sum'  =  forall a ac.
(Num a, AggregatedContext ac, SqlContext ac) =>
Record Flat (Maybe a) -> Record ac (Maybe a)
sumMaybe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c a. Record c a -> Record c (Maybe a)
Record.just

-- | Aggregation function AVG.
avgMaybe :: (Num a, Fractional b, AggregatedContext ac, SqlContext ac)
         => Record Flat (Maybe a) -> Record ac (Maybe b)
avgMaybe :: forall a b ac.
(Num a, Fractional b, AggregatedContext ac, SqlContext ac) =>
Record Flat (Maybe a) -> Record ac (Maybe b)
avgMaybe   =  forall ac a b.
(AggregatedContext ac, SqlContext ac) =>
StringSQL -> Record Flat a -> Record ac b
unsafeAggregateOp StringSQL
SQL.AVG

-- | Aggregation function AVG.
avg :: (Num a, Fractional b, AggregatedContext ac, SqlContext ac)
    => Record Flat a -> Record ac (Maybe b)
avg :: forall a b ac.
(Num a, Fractional b, AggregatedContext ac, SqlContext ac) =>
Record Flat a -> Record ac (Maybe b)
avg =  forall a b ac.
(Num a, Fractional b, AggregatedContext ac, SqlContext ac) =>
Record Flat (Maybe a) -> Record ac (Maybe b)
avgMaybe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c a. Record c a -> Record c (Maybe a)
Record.just

-- | Aggregation function MAX.
maxMaybe :: (Ord a, AggregatedContext ac, SqlContext ac)
         => Record Flat (Maybe a) -> Record ac (Maybe a)
maxMaybe :: forall a ac.
(Ord a, AggregatedContext ac, SqlContext ac) =>
Record Flat (Maybe a) -> Record ac (Maybe a)
maxMaybe  =  forall ac a b.
(AggregatedContext ac, SqlContext ac) =>
StringSQL -> Record Flat a -> Record ac b
unsafeAggregateOp StringSQL
SQL.MAX

-- | Aggregation function MAX.
max' :: (Ord a, AggregatedContext ac, SqlContext ac)
     => Record Flat a -> Record ac (Maybe a)
max' :: forall a ac.
(Ord a, AggregatedContext ac, SqlContext ac) =>
Record Flat a -> Record ac (Maybe a)
max' =  forall a ac.
(Ord a, AggregatedContext ac, SqlContext ac) =>
Record Flat (Maybe a) -> Record ac (Maybe a)
maxMaybe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c a. Record c a -> Record c (Maybe a)
Record.just

-- | Aggregation function MIN.
minMaybe :: (Ord a, AggregatedContext ac, SqlContext ac)
         => Record Flat (Maybe a) -> Record ac (Maybe a)
minMaybe :: forall a ac.
(Ord a, AggregatedContext ac, SqlContext ac) =>
Record Flat (Maybe a) -> Record ac (Maybe a)
minMaybe  =  forall ac a b.
(AggregatedContext ac, SqlContext ac) =>
StringSQL -> Record Flat a -> Record ac b
unsafeAggregateOp StringSQL
SQL.MIN

-- | Aggregation function MIN.
min' :: (Ord a, AggregatedContext ac, SqlContext ac)
     => Record Flat a -> Record ac (Maybe a)
min' :: forall a ac.
(Ord a, AggregatedContext ac, SqlContext ac) =>
Record Flat a -> Record ac (Maybe a)
min' =  forall a ac.
(Ord a, AggregatedContext ac, SqlContext ac) =>
Record Flat (Maybe a) -> Record ac (Maybe a)
minMaybe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c a. Record c a -> Record c (Maybe a)
Record.just

-- | Aggregation function EVERY.
every :: (AggregatedContext ac, SqlContext ac)
      => Predicate Flat -> Record ac (Maybe Bool)
every :: forall ac.
(AggregatedContext ac, SqlContext ac) =>
Predicate Flat -> Record ac (Maybe Bool)
every =  forall ac a b.
(AggregatedContext ac, SqlContext ac) =>
StringSQL -> Record Flat a -> Record ac b
unsafeAggregateOp StringSQL
SQL.EVERY

-- | Aggregation function ANY.
any' :: (AggregatedContext ac, SqlContext ac)
     => Predicate Flat -> Record ac (Maybe Bool)
any' :: forall ac.
(AggregatedContext ac, SqlContext ac) =>
Predicate Flat -> Record ac (Maybe Bool)
any'  =  forall ac a b.
(AggregatedContext ac, SqlContext ac) =>
StringSQL -> Record Flat a -> Record ac b
unsafeAggregateOp StringSQL
SQL.ANY

-- | Aggregation function SOME.
some' :: (AggregatedContext ac, SqlContext ac)
      => Predicate Flat -> Record ac (Maybe Bool)
some' :: forall ac.
(AggregatedContext ac, SqlContext ac) =>
Predicate Flat -> Record ac (Maybe Bool)
some' =  forall ac a b.
(AggregatedContext ac, SqlContext ac) =>
StringSQL -> Record Flat a -> Record ac b
unsafeAggregateOp StringSQL
SQL.SOME

-- | Get narrower record along with projection path.
(!) :: PersistableWidth a
    => Record c a -- ^ Source 'Record'
    -> Pi a b     -- ^ Record path
    -> Record c b -- ^ Narrower projected object
! :: forall a c b.
PersistableWidth a =>
Record c a -> Pi a b -> Record c b
(!) = forall a c b.
PersistableWidth a =>
Record c a -> Pi a b -> Record c b
Record.pi

-- | Get narrower record along with projection path
--   'Maybe' phantom functor is 'map'-ed.
(?!) :: PersistableWidth a
     => Record c (Maybe a) -- ^ Source 'Record'. 'Maybe' type
     -> Pi a b             -- ^ Record path
     -> Record c (Maybe b) -- ^ Narrower projected object. 'Maybe' type result
?! :: forall a c b.
PersistableWidth a =>
Record c (Maybe a) -> Pi a b -> Record c (Maybe b)
(?!) = forall a c b.
PersistableWidth a =>
Record c (Maybe a) -> Pi a b -> Record c (Maybe b)
Record.piMaybe

-- | Get narrower record along with projection path
--   and project into result record type.
--   Source record 'Maybe' phantom functor and projection path leaf 'Maybe' functor are 'join'-ed.
(?!?) :: PersistableWidth a
      => Record c (Maybe a) -- ^ Source 'Record'. 'Maybe' phantom type
      -> Pi a (Maybe b)     -- ^ Record path. 'Maybe' type leaf
      -> Record c (Maybe b) -- ^ Narrower projected object. 'Maybe' phantom type result
?!? :: forall a c b.
PersistableWidth a =>
Record c (Maybe a) -> Pi a (Maybe b) -> Record c (Maybe b)
(?!?) = forall a c b.
PersistableWidth a =>
Record c (Maybe a) -> Pi a (Maybe b) -> Record c (Maybe b)
Record.piMaybe'


-- | Interface to compose phantom 'Maybe' nested type.
class ProjectableFlattenMaybe a b where
  flatten :: ProjectableMaybe p => p a -> p b

-- | Compose 'Maybe' type in record phantom type.
instance ProjectableFlattenMaybe (Maybe a) b
         => ProjectableFlattenMaybe (Maybe (Maybe a)) b where
  flatten :: forall (p :: * -> *).
ProjectableMaybe p =>
p (Maybe (Maybe a)) -> p b
flatten = forall a b (p :: * -> *).
(ProjectableFlattenMaybe a b, ProjectableMaybe p) =>
p a -> p b
flatten forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (p :: * -> *) a.
ProjectableMaybe p =>
p (Maybe (Maybe a)) -> p (Maybe a)
flattenMaybe

-- | Not 'Maybe' type is not processed.
instance ProjectableFlattenMaybe (Maybe a) (Maybe a) where
  flatten :: forall (p :: * -> *).
ProjectableMaybe p =>
p (Maybe a) -> p (Maybe a)
flatten = forall a. a -> a
id

-- | Get narrower record with flatten leaf phantom Maybe types along with projection path.
flattenPiMaybe :: (PersistableWidth a, ProjectableFlattenMaybe (Maybe b) c)
               => Record cont (Maybe a) -- ^ Source 'Record'. 'Maybe' phantom type
               -> Pi a b                -- ^ Projection path
               -> Record cont c         -- ^ Narrower 'Record'. Flatten 'Maybe' phantom type
flattenPiMaybe :: forall a b c cont.
(PersistableWidth a, ProjectableFlattenMaybe (Maybe b) c) =>
Record cont (Maybe a) -> Pi a b -> Record cont c
flattenPiMaybe Record cont (Maybe a)
p = forall a b (p :: * -> *).
(ProjectableFlattenMaybe a b, ProjectableMaybe p) =>
p a -> p b
flatten forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a c b.
PersistableWidth a =>
Record c (Maybe a) -> Pi a b -> Record c (Maybe b)
Record.piMaybe Record cont (Maybe a)
p

-- | Get narrower record with flatten leaf phantom Maybe types along with projection path.
(!??) :: (PersistableWidth a, ProjectableFlattenMaybe (Maybe b) c)
      => Record cont (Maybe a) -- ^ Source 'Record'. 'Maybe' phantom type
      -> Pi a b                -- ^ Projection path
      -> Record cont c         -- ^ Narrower flatten and projected object.
!?? :: forall a b c cont.
(PersistableWidth a, ProjectableFlattenMaybe (Maybe b) c) =>
Record cont (Maybe a) -> Pi a b -> Record cont c
(!??) = forall a b c cont.
(PersistableWidth a, ProjectableFlattenMaybe (Maybe b) c) =>
Record cont (Maybe a) -> Pi a b -> Record cont c
flattenPiMaybe

-- | Same as '(?!)'. Use this operator like '(? #foo) mayX'.
(?) :: PersistableWidth a
    => Record c (Maybe a) -- ^ Source 'Record'. 'Maybe' type
    -> Pi a b             -- ^ Record path
    -> Record c (Maybe b) -- ^ Narrower projected object. 'Maybe' type result
? :: forall a c b.
PersistableWidth a =>
Record c (Maybe a) -> Pi a b -> Record c (Maybe b)
(?) = forall a c b.
PersistableWidth a =>
Record c (Maybe a) -> Pi a b -> Record c (Maybe b)
(?!)

-- | Same as '(?!?)'. Use this operator like '(?? #foo) mayX'.
(??) :: PersistableWidth a
     => Record c (Maybe a) -- ^ Source 'Record'. 'Maybe' phantom type
     -> Pi a (Maybe b)     -- ^ Record path. 'Maybe' type leaf
     -> Record c (Maybe b) -- ^ Narrower projected object. 'Maybe' phantom type result
?? :: forall a c b.
PersistableWidth a =>
Record c (Maybe a) -> Pi a (Maybe b) -> Record c (Maybe b)
(??) = forall a c b.
PersistableWidth a =>
Record c (Maybe a) -> Pi a (Maybe b) -> Record c (Maybe b)
(?!?)

infixl 8 !, ?, ??, ?!, ?!?, !??
infixl 7 .*., ./., ?*?, ?/?
infixl 6 .+., .-., ?+?, ?-?
infixl 5 .||., ?||?
infix  4 .=., .<>., .>., .>=., .<., .<=., `in'`, `like`, `likeMaybe`, `like'`, `likeMaybe'`
infixr 3 `and'`
infixr 2 `or'`
infixl 1  ><