{-# LANGUAGE CPP #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
module Database.Esqueleto.Experimental
(
From(..)
, on
, from
, (:&)(..)
, union_
, Union(..)
, unionAll_
, UnionAll(..)
, except_
, Except(..)
, intersect_
, Intersect(..)
, pattern SelectQuery
, with
, withRecursive
, ToFrom(..)
, ToMaybe(..)
, ToAlias(..)
, ToAliasT
, ToAliasReference(..)
, ToAliasReferenceT
, ValidOnClauseValue
, where_
, groupBy
, orderBy
, rand
, asc
, desc
, limit
, offset
, distinct
, distinctOn
, don
, distinctOnOrderBy
, having
, locking
, sub_select
, (^.)
, (?.)
, val
, isNothing
, just
, nothing
, joinV
, withNonNull
, countRows
, count
, countDistinct
, not_
, (==.)
, (>=.)
, (>.)
, (<=.)
, (<.)
, (!=.)
, (&&.)
, (||.)
, between
, (+.)
, (-.)
, (/.)
, (*.)
, random_
, round_
, ceiling_
, floor_
, min_
, max_
, sum_
, avg_
, castNum
, castNumM
, coalesce
, coalesceDefault
, lower_
, upper_
, trim_
, ltrim_
, rtrim_
, length_
, left_
, right_
, like
, ilike
, (%)
, concat_
, (++.)
, castString
, subList_select
, valList
, justList
, in_
, notIn
, exists
, notExists
, set
, (=.)
, (+=.)
, (-=.)
, (*=.)
, (/=.)
, case_
, toBaseId
, subSelect
, subSelectMaybe
, subSelectCount
, subSelectForeign
, subSelectList
, subSelectUnsafe
, ToBaseId(..)
, when_
, then_
, else_
, Value(..)
, ValueList(..)
, OrderBy
, DistinctOn
, LockingKind(..)
, SqlString
, InnerJoin(..)
, CrossJoin(..)
, LeftOuterJoin(..)
, RightOuterJoin(..)
, FullOuterJoin(..)
, JoinKind(..)
, OnClauseWithoutMatchingJoinException(..)
, SqlQuery
, SqlExpr
, SqlEntity
, select
, selectSource
, delete
, deleteCount
, update
, updateCount
, insertSelect
, insertSelectCount
, (<#)
, (<&>)
, renderQueryToText
, renderQuerySelect
, renderQueryUpdate
, renderQueryDelete
, renderQueryInsertInto
, valkey
, valJ
, associateJoin
, deleteKey
, module Database.Esqueleto.Internal.PersistentImport
) where
import Control.Monad.Trans.Class (lift)
import qualified Control.Monad.Trans.State as S
import qualified Control.Monad.Trans.Writer as W
#if __GLASGOW_HASKELL__ < 804
import Data.Semigroup
#endif
import Data.Kind (Constraint)
import Data.Proxy (Proxy(..))
import qualified Data.Text.Lazy.Builder as TLB
import Database.Esqueleto.Internal.Internal hiding (From, from, on)
import Database.Esqueleto.Internal.PersistentImport
import GHC.TypeLits
data (:&) a b = a :& b
infixl 2 :&
data SqlSetOperation a
= SqlSetUnion (SqlSetOperation a) (SqlSetOperation a)
| SqlSetUnionAll (SqlSetOperation a) (SqlSetOperation a)
| SqlSetExcept (SqlSetOperation a) (SqlSetOperation a)
| SqlSetIntersect (SqlSetOperation a) (SqlSetOperation a)
| SelectQueryP NeedParens (SqlQuery a)
{-# DEPRECATED Union "/Since: 3.4.0.0/ - Use the 'union_' function instead of the 'Union' data constructor" #-}
data Union a b = a `Union` b
union_ :: a -> b -> Union a b
union_ :: a -> b -> Union a b
union_ = a -> b -> Union a b
forall a b. a -> b -> Union a b
Union
{-# DEPRECATED UnionAll "/Since: 3.4.0.0/ - Use the 'unionAll_' function instead of the 'UnionAll' data constructor" #-}
data UnionAll a b = a `UnionAll` b
unionAll_ :: a -> b -> UnionAll a b
unionAll_ :: a -> b -> UnionAll a b
unionAll_ = a -> b -> UnionAll a b
forall a b. a -> b -> UnionAll a b
UnionAll
{-# DEPRECATED Except "/Since: 3.4.0.0/ - Use the 'except_' function instead of the 'Except' data constructor" #-}
data Except a b = a `Except` b
except_ :: a -> b -> Except a b
except_ :: a -> b -> Except a b
except_ = a -> b -> Except a b
forall a b. a -> b -> Except a b
Except
{-# DEPRECATED Intersect "/Since: 3.4.0.0/ - Use the 'intersect_' function instead of the 'Intersect' data constructor" #-}
data Intersect a b = a `Intersect` b
intersect_ :: a -> b -> Intersect a b
intersect_ :: a -> b -> Intersect a b
intersect_ = a -> b -> Intersect a b
forall a b. a -> b -> Intersect a b
Intersect
class SetOperationT a ~ b => ToSetOperation a b | a -> b where
type SetOperationT a
toSetOperation :: a -> SqlSetOperation b
instance ToSetOperation (SqlSetOperation a) a where
type SetOperationT (SqlSetOperation a) = a
toSetOperation :: SqlSetOperation a -> SqlSetOperation a
toSetOperation = SqlSetOperation a -> SqlSetOperation a
forall a. a -> a
id
instance ToSetOperation (SqlQuery a) a where
type SetOperationT (SqlQuery a) = a
toSetOperation :: SqlQuery a -> SqlSetOperation a
toSetOperation = NeedParens -> SqlQuery a -> SqlSetOperation a
forall a. NeedParens -> SqlQuery a -> SqlSetOperation a
SelectQueryP NeedParens
Never
instance (ToSetOperation a c, ToSetOperation b c) => ToSetOperation (Union a b) c where
type SetOperationT (Union a b) = SetOperationT a
toSetOperation :: Union a b -> SqlSetOperation c
toSetOperation (Union a
a b
b) = SqlSetOperation c -> SqlSetOperation c -> SqlSetOperation c
forall a.
SqlSetOperation a -> SqlSetOperation a -> SqlSetOperation a
SqlSetUnion (a -> SqlSetOperation c
forall a b. ToSetOperation a b => a -> SqlSetOperation b
toSetOperation a
a) (b -> SqlSetOperation c
forall a b. ToSetOperation a b => a -> SqlSetOperation b
toSetOperation b
b)
instance (ToSetOperation a c, ToSetOperation b c) => ToSetOperation (UnionAll a b) c where
type SetOperationT (UnionAll a b) = SetOperationT a
toSetOperation :: UnionAll a b -> SqlSetOperation c
toSetOperation (UnionAll a
a b
b) = SqlSetOperation c -> SqlSetOperation c -> SqlSetOperation c
forall a.
SqlSetOperation a -> SqlSetOperation a -> SqlSetOperation a
SqlSetUnionAll (a -> SqlSetOperation c
forall a b. ToSetOperation a b => a -> SqlSetOperation b
toSetOperation a
a) (b -> SqlSetOperation c
forall a b. ToSetOperation a b => a -> SqlSetOperation b
toSetOperation b
b)
instance (ToSetOperation a c, ToSetOperation b c) => ToSetOperation (Except a b) c where
type SetOperationT (Except a b) = SetOperationT a
toSetOperation :: Except a b -> SqlSetOperation c
toSetOperation (Except a
a b
b) = SqlSetOperation c -> SqlSetOperation c -> SqlSetOperation c
forall a.
SqlSetOperation a -> SqlSetOperation a -> SqlSetOperation a
SqlSetExcept (a -> SqlSetOperation c
forall a b. ToSetOperation a b => a -> SqlSetOperation b
toSetOperation a
a) (b -> SqlSetOperation c
forall a b. ToSetOperation a b => a -> SqlSetOperation b
toSetOperation b
b)
instance (ToSetOperation a c, ToSetOperation b c) => ToSetOperation (Intersect a b) c where
type SetOperationT (Intersect a b) = SetOperationT a
toSetOperation :: Intersect a b -> SqlSetOperation c
toSetOperation (Intersect a
a b
b) = SqlSetOperation c -> SqlSetOperation c -> SqlSetOperation c
forall a.
SqlSetOperation a -> SqlSetOperation a -> SqlSetOperation a
SqlSetIntersect (a -> SqlSetOperation c
forall a b. ToSetOperation a b => a -> SqlSetOperation b
toSetOperation a
a) (b -> SqlSetOperation c
forall a b. ToSetOperation a b => a -> SqlSetOperation b
toSetOperation b
b)
{-# DEPRECATED SelectQuery "/Since: 3.4.0.0/ - It is no longer necessary to tag 'SqlQuery' values with @SelectQuery@" #-}
pattern SelectQuery :: SqlQuery a -> SqlSetOperation a
pattern $bSelectQuery :: SqlQuery a -> SqlSetOperation a
$mSelectQuery :: forall r a.
SqlSetOperation a -> (SqlQuery a -> r) -> (Void# -> r) -> r
SelectQuery q = SelectQueryP Never q
data From a where
Table
:: PersistEntity ent
=> From (SqlExpr (Entity ent))
SubQuery
:: ( SqlSelect a r
, ToAlias a
, ToAliasReference a
)
=> SqlQuery a
-> From a
FromCte
:: Ident
-> a
-> From a
SqlSetOperation
:: ( SqlSelect a r
, ToAlias a
, ToAliasReference a
)
=> SqlSetOperation a
-> From a
InnerJoinFrom
:: From a
-> (From b, (a :& b) -> SqlExpr (Value Bool))
-> From (a :& b)
InnerJoinFromLateral
:: ( SqlSelect b r
, ToAlias b
, ToAliasReference b
)
=> From a
-> ((a -> SqlQuery b), (a :& b) -> SqlExpr (Value Bool))
-> From (a :& b)
CrossJoinFrom
:: From a
-> From b
-> From (a :& b)
CrossJoinFromLateral
:: ( SqlSelect b r
, ToAlias b
, ToAliasReference b
)
=> From a
-> (a -> SqlQuery b)
-> From (a :& b)
LeftJoinFrom
:: ToMaybe b
=> From a
-> (From b, (a :& ToMaybeT b) -> SqlExpr (Value Bool))
-> From (a :& ToMaybeT b)
LeftJoinFromLateral
:: ( SqlSelect b r
, ToAlias b
, ToAliasReference b
, ToMaybe b
)
=> From a
-> ((a -> SqlQuery b), (a :& ToMaybeT b) -> SqlExpr (Value Bool))
-> From (a :& ToMaybeT b)
RightJoinFrom
:: ToMaybe a
=> From a
-> (From b, (ToMaybeT a :& b) -> SqlExpr (Value Bool))
-> From (ToMaybeT a :& b)
FullJoinFrom
:: (ToMaybe a, ToMaybe b )
=> From a
-> (From b, (ToMaybeT a :& ToMaybeT b) -> SqlExpr (Value Bool))
-> From (ToMaybeT a :& ToMaybeT b)
type family ValidOnClauseValue a :: Constraint where
ValidOnClauseValue (From a) = ()
ValidOnClauseValue (SqlQuery a) = ()
ValidOnClauseValue (SqlSetOperation a) = ()
ValidOnClauseValue (a -> SqlQuery b) = ()
ValidOnClauseValue _ = TypeError ('Text "Illegal use of ON")
on :: ValidOnClauseValue a => a -> (b -> SqlExpr (Value Bool)) -> (a, b -> SqlExpr (Value Bool))
on :: a -> (b -> SqlExpr (Value Bool)) -> (a, b -> SqlExpr (Value Bool))
on = (,)
infix 9 `on`
data Lateral
data NotLateral
type family IsLateral a where
IsLateral (a -> SqlQuery b) = Lateral
IsLateral a = NotLateral
type family ErrorOnLateral a :: Constraint where
ErrorOnLateral (a -> SqlQuery b) = TypeError ('Text "LATERAL can only be used for INNER, LEFT, and CROSS join kinds.")
ErrorOnLateral _ = ()
class ToFrom a where
type ToFromT a
toFrom :: a -> From (ToFromT a)
type family FromOnClause a where
FromOnClause (a, b -> SqlExpr (Value Bool)) = b
FromOnClause a = TypeError ('Text "Missing ON clause")
instance {-# OVERLAPPABLE #-} ToFrom (InnerJoin a b) where
type ToFromT (InnerJoin a b) = FromOnClause b
toFrom :: InnerJoin a b -> From (ToFromT (InnerJoin a b))
toFrom = InnerJoin a b -> From (ToFromT (InnerJoin a b))
forall a. HasCallStack => a
undefined
instance {-# OVERLAPPABLE #-} ToFrom (LeftOuterJoin a b) where
type ToFromT (LeftOuterJoin a b) = FromOnClause b
toFrom :: LeftOuterJoin a b -> From (ToFromT (LeftOuterJoin a b))
toFrom = LeftOuterJoin a b -> From (ToFromT (LeftOuterJoin a b))
forall a. HasCallStack => a
undefined
instance {-# OVERLAPPABLE #-} ToFrom (FullOuterJoin a b) where
type ToFromT (FullOuterJoin a b) = FromOnClause b
toFrom :: FullOuterJoin a b -> From (ToFromT (FullOuterJoin a b))
toFrom = FullOuterJoin a b -> From (ToFromT (FullOuterJoin a b))
forall a. HasCallStack => a
undefined
instance {-# OVERLAPPABLE #-} ToFrom (RightOuterJoin a b) where
type ToFromT (RightOuterJoin a b) = FromOnClause b
toFrom :: RightOuterJoin a b -> From (ToFromT (RightOuterJoin a b))
toFrom = RightOuterJoin a b -> From (ToFromT (RightOuterJoin a b))
forall a. HasCallStack => a
undefined
instance ToFrom (From a) where
type ToFromT (From a) = a
toFrom :: From a -> From (ToFromT (From a))
toFrom = From a -> From (ToFromT (From a))
forall a. a -> a
id
instance
( ToAlias a
, ToAliasReference a
, SqlSelect a r
)
=>
ToFrom (SqlQuery a)
where
type ToFromT (SqlQuery a) = a
toFrom :: SqlQuery a -> From (ToFromT (SqlQuery a))
toFrom = SqlQuery a -> From (ToFromT (SqlQuery a))
forall a r.
(SqlSelect a r, ToAlias a, ToAliasReference a) =>
SqlQuery a -> From a
SubQuery
instance
( SqlSelect c r
, ToAlias c
, ToAliasReference c
, ToSetOperation a c
, ToSetOperation b c
, c ~ SetOperationT a
)
=>
ToFrom (Union a b)
where
type ToFromT (Union a b) = SetOperationT a
toFrom :: Union a b -> From (ToFromT (Union a b))
toFrom Union a b
u = SqlSetOperation c -> From c
forall a r.
(SqlSelect a r, ToAlias a, ToAliasReference a) =>
SqlSetOperation a -> From a
SqlSetOperation (SqlSetOperation c -> From c) -> SqlSetOperation c -> From c
forall a b. (a -> b) -> a -> b
$ Union a b -> SqlSetOperation c
forall a b. ToSetOperation a b => a -> SqlSetOperation b
toSetOperation Union a b
u
instance
( SqlSelect c r
, ToAlias c
, ToAliasReference c
, ToSetOperation a c
, ToSetOperation b c
, c ~ SetOperationT a
)
=>
ToFrom (UnionAll a b)
where
type ToFromT (UnionAll a b) = SetOperationT a
toFrom :: UnionAll a b -> From (ToFromT (UnionAll a b))
toFrom UnionAll a b
u = SqlSetOperation c -> From c
forall a r.
(SqlSelect a r, ToAlias a, ToAliasReference a) =>
SqlSetOperation a -> From a
SqlSetOperation (SqlSetOperation c -> From c) -> SqlSetOperation c -> From c
forall a b. (a -> b) -> a -> b
$ UnionAll a b -> SqlSetOperation c
forall a b. ToSetOperation a b => a -> SqlSetOperation b
toSetOperation UnionAll a b
u
instance
( SqlSelect c r
, ToAlias c
, ToAliasReference c
, ToSetOperation a c
, ToSetOperation b c
, c ~ SetOperationT a
)
=>
ToFrom (Intersect a b)
where
type ToFromT (Intersect a b) = SetOperationT a
toFrom :: Intersect a b -> From (ToFromT (Intersect a b))
toFrom Intersect a b
u = SqlSetOperation c -> From c
forall a r.
(SqlSelect a r, ToAlias a, ToAliasReference a) =>
SqlSetOperation a -> From a
SqlSetOperation (SqlSetOperation c -> From c) -> SqlSetOperation c -> From c
forall a b. (a -> b) -> a -> b
$ Intersect a b -> SqlSetOperation c
forall a b. ToSetOperation a b => a -> SqlSetOperation b
toSetOperation Intersect a b
u
instance
( SqlSelect c r
, ToAlias c
, ToAliasReference c
, ToSetOperation a c
, ToSetOperation b c
, c ~ SetOperationT a
)
=>
ToFrom (Except a b)
where
type ToFromT (Except a b) = SetOperationT a
toFrom :: Except a b -> From (ToFromT (Except a b))
toFrom Except a b
u = SqlSetOperation c -> From c
forall a r.
(SqlSelect a r, ToAlias a, ToAliasReference a) =>
SqlSetOperation a -> From a
SqlSetOperation (SqlSetOperation c -> From c) -> SqlSetOperation c -> From c
forall a b. (a -> b) -> a -> b
$ Except a b -> SqlSetOperation c
forall a b. ToSetOperation a b => a -> SqlSetOperation b
toSetOperation Except a b
u
instance (SqlSelect a r, ToAlias a, ToAliasReference a) => ToFrom (SqlSetOperation a) where
type ToFromT (SqlSetOperation a) = a
toFrom :: SqlSetOperation a -> From (ToFromT (SqlSetOperation a))
toFrom (SelectQueryP NeedParens
_ SqlQuery a
q) = SqlQuery a -> From a
forall a r.
(SqlSelect a r, ToAlias a, ToAliasReference a) =>
SqlQuery a -> From a
SubQuery SqlQuery a
q
toFrom SqlSetOperation a
q = SqlSetOperation a -> From a
forall a r.
(SqlSelect a r, ToAlias a, ToAliasReference a) =>
SqlSetOperation a -> From a
SqlSetOperation SqlSetOperation a
q
class ToInnerJoin lateral lhs rhs res where
toInnerJoin :: Proxy lateral -> lhs -> rhs -> (res -> SqlExpr (Value Bool)) -> From res
instance ( SqlSelect b r
, ToAlias b
, ToAliasReference b
, ToFrom a
, ToFromT a ~ a'
) => ToInnerJoin Lateral a (a' -> SqlQuery b) (a' :& b) where
toInnerJoin :: Proxy Lateral
-> a
-> (a' -> SqlQuery b)
-> ((a' :& b) -> SqlExpr (Value Bool))
-> From (a' :& b)
toInnerJoin Proxy Lateral
_ a
lhs a' -> SqlQuery b
q (a' :& b) -> SqlExpr (Value Bool)
on' = From a'
-> (a' -> SqlQuery b, (a' :& b) -> SqlExpr (Value Bool))
-> From (a' :& b)
forall b r a.
(SqlSelect b r, ToAlias b, ToAliasReference b) =>
From a
-> (a -> SqlQuery b, (a :& b) -> SqlExpr (Value Bool))
-> From (a :& b)
InnerJoinFromLateral (a -> From (ToFromT a)
forall a. ToFrom a => a -> From (ToFromT a)
toFrom a
lhs) (a' -> SqlQuery b
q, (a' :& b) -> SqlExpr (Value Bool)
on')
instance (ToFrom a, ToFromT a ~ a', ToFrom b, ToFromT b ~ b')
=> ToInnerJoin NotLateral a b (a' :& b') where
toInnerJoin :: Proxy NotLateral
-> a
-> b
-> ((a' :& b') -> SqlExpr (Value Bool))
-> From (a' :& b')
toInnerJoin Proxy NotLateral
_ a
lhs b
rhs (a' :& b') -> SqlExpr (Value Bool)
on' = From a'
-> (From b', (a' :& b') -> SqlExpr (Value Bool)) -> From (a' :& b')
forall a b.
From a
-> (From b, (a :& b) -> SqlExpr (Value Bool)) -> From (a :& b)
InnerJoinFrom (a -> From (ToFromT a)
forall a. ToFrom a => a -> From (ToFromT a)
toFrom a
lhs) (b -> From (ToFromT b)
forall a. ToFrom a => a -> From (ToFromT a)
toFrom b
rhs, (a' :& b') -> SqlExpr (Value Bool)
on')
instance (ToInnerJoin (IsLateral b) a b b') => ToFrom (InnerJoin a (b, b' -> SqlExpr (Value Bool))) where
type ToFromT (InnerJoin a (b, b' -> SqlExpr (Value Bool))) = FromOnClause (b, b' -> SqlExpr(Value Bool))
toFrom :: InnerJoin a (b, b' -> SqlExpr (Value Bool))
-> From (ToFromT (InnerJoin a (b, b' -> SqlExpr (Value Bool))))
toFrom (InnerJoin a
lhs (b
rhs, b' -> SqlExpr (Value Bool)
on')) = Proxy (IsLateral b)
-> a -> b -> (b' -> SqlExpr (Value Bool)) -> From b'
forall lateral lhs rhs res.
ToInnerJoin lateral lhs rhs res =>
Proxy lateral
-> lhs -> rhs -> (res -> SqlExpr (Value Bool)) -> From res
toInnerJoin (b -> Proxy (IsLateral b)
forall b. b -> Proxy (IsLateral b)
toProxy b
rhs) a
lhs b
rhs b' -> SqlExpr (Value Bool)
on'
where
toProxy :: b -> Proxy (IsLateral b)
toProxy :: b -> Proxy (IsLateral b)
toProxy b
_ = Proxy (IsLateral b)
forall k (t :: k). Proxy t
Proxy
type family FromCrossJoin a b where
FromCrossJoin a (b -> SqlQuery c) = ToFromT a :& c
FromCrossJoin a b = ToFromT a :& ToFromT b
instance ( ToFrom a
, ToFrom b
, ToFromT (CrossJoin a b) ~ (ToFromT a :& ToFromT b)
) => ToFrom (CrossJoin a b) where
type ToFromT (CrossJoin a b) = FromCrossJoin a b
toFrom :: CrossJoin a b -> From (ToFromT (CrossJoin a b))
toFrom (CrossJoin a
lhs b
rhs) = From (ToFromT a)
-> From (ToFromT b) -> From (ToFromT a :& ToFromT b)
forall a b. From a -> From b -> From (a :& b)
CrossJoinFrom (a -> From (ToFromT a)
forall a. ToFrom a => a -> From (ToFromT a)
toFrom a
lhs) (b -> From (ToFromT b)
forall a. ToFrom a => a -> From (ToFromT a)
toFrom b
rhs)
instance {-# OVERLAPPING #-}
( ToFrom a
, ToFromT a ~ a'
, SqlSelect b r
, ToAlias b
, ToAliasReference b
) => ToFrom (CrossJoin a (a' -> SqlQuery b)) where
type ToFromT (CrossJoin a (a' -> SqlQuery b)) = FromCrossJoin a (a' -> SqlQuery b)
toFrom :: CrossJoin a (a' -> SqlQuery b)
-> From (ToFromT (CrossJoin a (a' -> SqlQuery b)))
toFrom (CrossJoin a
lhs a' -> SqlQuery b
q) = From a' -> (a' -> SqlQuery b) -> From (a' :& b)
forall b r a.
(SqlSelect b r, ToAlias b, ToAliasReference b) =>
From a -> (a -> SqlQuery b) -> From (a :& b)
CrossJoinFromLateral (a -> From (ToFromT a)
forall a. ToFrom a => a -> From (ToFromT a)
toFrom a
lhs) a' -> SqlQuery b
q
class ToLeftJoin lateral lhs rhs res where
toLeftJoin :: Proxy lateral -> lhs -> rhs -> (res -> SqlExpr (Value Bool)) -> From res
instance ( ToFrom a
, ToFromT a ~ a'
, SqlSelect b r
, ToAlias b
, ToAliasReference b
, ToMaybe b
, mb ~ ToMaybeT b
) => ToLeftJoin Lateral a (a' -> SqlQuery b) (a' :& mb) where
toLeftJoin :: Proxy Lateral
-> a
-> (a' -> SqlQuery b)
-> ((a' :& mb) -> SqlExpr (Value Bool))
-> From (a' :& mb)
toLeftJoin Proxy Lateral
_ a
lhs a' -> SqlQuery b
q (a' :& mb) -> SqlExpr (Value Bool)
on' = From a'
-> (a' -> SqlQuery b, (a' :& ToMaybeT b) -> SqlExpr (Value Bool))
-> From (a' :& ToMaybeT b)
forall a r a.
(SqlSelect a r, ToAlias a, ToAliasReference a, ToMaybe a) =>
From a
-> (a -> SqlQuery a, (a :& ToMaybeT a) -> SqlExpr (Value Bool))
-> From (a :& ToMaybeT a)
LeftJoinFromLateral (a -> From (ToFromT a)
forall a. ToFrom a => a -> From (ToFromT a)
toFrom a
lhs) (a' -> SqlQuery b
q, (a' :& mb) -> SqlExpr (Value Bool)
(a' :& ToMaybeT b) -> SqlExpr (Value Bool)
on')
instance ( ToFrom a
, ToFromT a ~ a'
, ToFrom b
, ToFromT b ~ b'
, ToMaybe b'
, mb ~ ToMaybeT b'
) => ToLeftJoin NotLateral a b (a' :& mb) where
toLeftJoin :: Proxy NotLateral
-> a
-> b
-> ((a' :& mb) -> SqlExpr (Value Bool))
-> From (a' :& mb)
toLeftJoin Proxy NotLateral
_ a
lhs b
rhs (a' :& mb) -> SqlExpr (Value Bool)
on' = From a'
-> (From b', (a' :& ToMaybeT b') -> SqlExpr (Value Bool))
-> From (a' :& ToMaybeT b')
forall b a.
ToMaybe b =>
From a
-> (From b, (a :& ToMaybeT b) -> SqlExpr (Value Bool))
-> From (a :& ToMaybeT b)
LeftJoinFrom (a -> From (ToFromT a)
forall a. ToFrom a => a -> From (ToFromT a)
toFrom a
lhs) (b -> From (ToFromT b)
forall a. ToFrom a => a -> From (ToFromT a)
toFrom b
rhs, (a' :& mb) -> SqlExpr (Value Bool)
(a' :& ToMaybeT b') -> SqlExpr (Value Bool)
on')
instance ( ToLeftJoin (IsLateral b) a b b'
) => ToFrom (LeftOuterJoin a (b, b' -> SqlExpr (Value Bool))) where
type ToFromT (LeftOuterJoin a (b, b' -> SqlExpr (Value Bool))) = FromOnClause (b, b' -> SqlExpr(Value Bool))
toFrom :: LeftOuterJoin a (b, b' -> SqlExpr (Value Bool))
-> From (ToFromT (LeftOuterJoin a (b, b' -> SqlExpr (Value Bool))))
toFrom (LeftOuterJoin a
lhs (b
rhs, b' -> SqlExpr (Value Bool)
on')) =
Proxy (IsLateral b)
-> a -> b -> (b' -> SqlExpr (Value Bool)) -> From b'
forall lateral lhs rhs res.
ToLeftJoin lateral lhs rhs res =>
Proxy lateral
-> lhs -> rhs -> (res -> SqlExpr (Value Bool)) -> From res
toLeftJoin (b -> Proxy (IsLateral b)
forall b. b -> Proxy (IsLateral b)
toProxy b
rhs) a
lhs b
rhs b' -> SqlExpr (Value Bool)
on'
where
toProxy :: b -> Proxy (IsLateral b)
toProxy :: b -> Proxy (IsLateral b)
toProxy b
_ = Proxy (IsLateral b)
forall k (t :: k). Proxy t
Proxy
instance ( ToFrom a
, ToFromT a ~ a'
, ToFrom b
, ToFromT b ~ b'
, ToMaybe a'
, ma ~ ToMaybeT a'
, ToMaybe b'
, mb ~ ToMaybeT b'
, ErrorOnLateral b
) => ToFrom (FullOuterJoin a (b, (ma :& mb) -> SqlExpr (Value Bool))) where
type ToFromT (FullOuterJoin a (b, (ma :& mb) -> SqlExpr (Value Bool))) = FromOnClause (b, (ma :& mb) -> SqlExpr(Value Bool))
toFrom :: FullOuterJoin a (b, (ma :& mb) -> SqlExpr (Value Bool))
-> From
(ToFromT (FullOuterJoin a (b, (ma :& mb) -> SqlExpr (Value Bool))))
toFrom (FullOuterJoin a
lhs (b
rhs, (ma :& mb) -> SqlExpr (Value Bool)
on')) = From a'
-> (From b', (ToMaybeT a' :& ToMaybeT b') -> SqlExpr (Value Bool))
-> From (ToMaybeT a' :& ToMaybeT b')
forall b b.
(ToMaybe b, ToMaybe b) =>
From b
-> (From b, (ToMaybeT b :& ToMaybeT b) -> SqlExpr (Value Bool))
-> From (ToMaybeT b :& ToMaybeT b)
FullJoinFrom (a -> From (ToFromT a)
forall a. ToFrom a => a -> From (ToFromT a)
toFrom a
lhs) (b -> From (ToFromT b)
forall a. ToFrom a => a -> From (ToFromT a)
toFrom b
rhs, (ma :& mb) -> SqlExpr (Value Bool)
(ToMaybeT a' :& ToMaybeT b') -> SqlExpr (Value Bool)
on')
instance ( ToFrom a
, ToFromT a ~ a'
, ToMaybe a'
, ma ~ ToMaybeT a'
, ToFrom b
, ToFromT b ~ b'
, ErrorOnLateral b
) => ToFrom (RightOuterJoin a (b, (ma :& b') -> SqlExpr (Value Bool))) where
type ToFromT (RightOuterJoin a (b, (ma :& b') -> SqlExpr (Value Bool))) = FromOnClause (b, (ma :& b') -> SqlExpr(Value Bool))
toFrom :: RightOuterJoin a (b, (ma :& b') -> SqlExpr (Value Bool))
-> From
(ToFromT
(RightOuterJoin a (b, (ma :& b') -> SqlExpr (Value Bool))))
toFrom (RightOuterJoin a
lhs (b
rhs, (ma :& b') -> SqlExpr (Value Bool)
on')) = From a'
-> (From b', (ToMaybeT a' :& b') -> SqlExpr (Value Bool))
-> From (ToMaybeT a' :& b')
forall a b.
ToMaybe a =>
From a
-> (From b, (ToMaybeT a :& b) -> SqlExpr (Value Bool))
-> From (ToMaybeT a :& b)
RightJoinFrom (a -> From (ToFromT a)
forall a. ToFrom a => a -> From (ToFromT a)
toFrom a
lhs) (b -> From (ToFromT b)
forall a. ToFrom a => a -> From (ToFromT a)
toFrom b
rhs, (ma :& b') -> SqlExpr (Value Bool)
(ToMaybeT a' :& b') -> SqlExpr (Value Bool)
on')
type family Nullable a where
Nullable (Maybe a) = a
Nullable a = a
class ToMaybe a where
type ToMaybeT a
toMaybe :: a -> ToMaybeT a
instance ToMaybe (SqlExpr (Maybe a)) where
type ToMaybeT (SqlExpr (Maybe a)) = SqlExpr (Maybe a)
toMaybe :: SqlExpr (Maybe a) -> ToMaybeT (SqlExpr (Maybe a))
toMaybe = SqlExpr (Maybe a) -> ToMaybeT (SqlExpr (Maybe a))
forall a. a -> a
id
instance ToMaybe (SqlExpr (Entity a)) where
type ToMaybeT (SqlExpr (Entity a)) = SqlExpr (Maybe (Entity a))
toMaybe :: SqlExpr (Entity a) -> ToMaybeT (SqlExpr (Entity a))
toMaybe = SqlExpr (Entity a) -> ToMaybeT (SqlExpr (Entity a))
forall a. SqlExpr a -> SqlExpr (Maybe a)
EMaybe
instance ToMaybe (SqlExpr (Value a)) where
type ToMaybeT (SqlExpr (Value a)) = SqlExpr (Value (Maybe (Nullable a)))
toMaybe :: SqlExpr (Value a) -> ToMaybeT (SqlExpr (Value a))
toMaybe = SqlExpr (Value a) -> ToMaybeT (SqlExpr (Value a))
forall a b. SqlExpr (Value a) -> SqlExpr (Value b)
veryUnsafeCoerceSqlExprValue
instance (ToMaybe a, ToMaybe b) => ToMaybe (a :& b) where
type ToMaybeT (a :& b) = (ToMaybeT a :& ToMaybeT b)
toMaybe :: (a :& b) -> ToMaybeT (a :& b)
toMaybe (a
a :& b
b) = (a -> ToMaybeT a
forall a. ToMaybe a => a -> ToMaybeT a
toMaybe a
a ToMaybeT a -> ToMaybeT b -> ToMaybeT a :& ToMaybeT b
forall a b. a -> b -> a :& b
:& b -> ToMaybeT b
forall a. ToMaybe a => a -> ToMaybeT a
toMaybe b
b)
instance (ToMaybe a, ToMaybe b) => ToMaybe (a,b) where
type ToMaybeT (a, b) = (ToMaybeT a, ToMaybeT b)
toMaybe :: (a, b) -> ToMaybeT (a, b)
toMaybe (a
a, b
b) = (a -> ToMaybeT a
forall a. ToMaybe a => a -> ToMaybeT a
toMaybe a
a, b -> ToMaybeT b
forall a. ToMaybe a => a -> ToMaybeT a
toMaybe b
b)
instance ( ToMaybe a , ToMaybe b , ToMaybe c) => ToMaybe (a,b,c) where
type ToMaybeT (a, b, c) = (ToMaybeT a, ToMaybeT b, ToMaybeT c)
toMaybe :: (a, b, c) -> ToMaybeT (a, b, c)
toMaybe = ((ToMaybeT a, ToMaybeT b), ToMaybeT c)
-> (ToMaybeT a, ToMaybeT b, ToMaybeT c)
forall a b c. ((a, b), c) -> (a, b, c)
to3 (((ToMaybeT a, ToMaybeT b), ToMaybeT c)
-> (ToMaybeT a, ToMaybeT b, ToMaybeT c))
-> ((a, b, c) -> ((ToMaybeT a, ToMaybeT b), ToMaybeT c))
-> (a, b, c)
-> (ToMaybeT a, ToMaybeT b, ToMaybeT c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((a, b), c) -> ((ToMaybeT a, ToMaybeT b), ToMaybeT c)
forall a. ToMaybe a => a -> ToMaybeT a
toMaybe (((a, b), c) -> ((ToMaybeT a, ToMaybeT b), ToMaybeT c))
-> ((a, b, c) -> ((a, b), c))
-> (a, b, c)
-> ((ToMaybeT a, ToMaybeT b), ToMaybeT c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, b, c) -> ((a, b), c)
forall a b c. (a, b, c) -> ((a, b), c)
from3
instance ( ToMaybe a , ToMaybe b , ToMaybe c , ToMaybe d) => ToMaybe (a,b,c,d) where
type ToMaybeT (a, b, c, d) = (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d)
toMaybe :: (a, b, c, d) -> ToMaybeT (a, b, c, d)
toMaybe = ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d))
-> (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d)
forall a b c d. ((a, b), (c, d)) -> (a, b, c, d)
to4 (((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d))
-> (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d))
-> ((a, b, c, d)
-> ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d)))
-> (a, b, c, d)
-> (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((a, b), (c, d))
-> ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d))
forall a. ToMaybe a => a -> ToMaybeT a
toMaybe (((a, b), (c, d))
-> ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d)))
-> ((a, b, c, d) -> ((a, b), (c, d)))
-> (a, b, c, d)
-> ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, b, c, d) -> ((a, b), (c, d))
forall a b c d. (a, b, c, d) -> ((a, b), (c, d))
from4
instance ( ToMaybe a , ToMaybe b , ToMaybe c , ToMaybe d , ToMaybe e) => ToMaybe (a,b,c,d,e) where
type ToMaybeT (a, b, c, d, e) = (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d, ToMaybeT e)
toMaybe :: (a, b, c, d, e) -> ToMaybeT (a, b, c, d, e)
toMaybe = ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d), ToMaybeT e)
-> (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d, ToMaybeT e)
forall a b c d e. ((a, b), (c, d), e) -> (a, b, c, d, e)
to5 (((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d), ToMaybeT e)
-> (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d, ToMaybeT e))
-> ((a, b, c, d, e)
-> ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d),
ToMaybeT e))
-> (a, b, c, d, e)
-> (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d, ToMaybeT e)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((a, b), (c, d), e)
-> ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d), ToMaybeT e)
forall a. ToMaybe a => a -> ToMaybeT a
toMaybe (((a, b), (c, d), e)
-> ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d),
ToMaybeT e))
-> ((a, b, c, d, e) -> ((a, b), (c, d), e))
-> (a, b, c, d, e)
-> ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d), ToMaybeT e)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, b, c, d, e) -> ((a, b), (c, d), e)
forall a b c d e. (a, b, c, d, e) -> ((a, b), (c, d), e)
from5
instance ( ToMaybe a
, ToMaybe b
, ToMaybe c
, ToMaybe d
, ToMaybe e
, ToMaybe f
) => ToMaybe (a,b,c,d,e,f) where
type ToMaybeT (a, b, c, d, e, f) = (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d, ToMaybeT e, ToMaybeT f)
toMaybe :: (a, b, c, d, e, f) -> ToMaybeT (a, b, c, d, e, f)
toMaybe = ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d),
(ToMaybeT e, ToMaybeT f))
-> (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d, ToMaybeT e,
ToMaybeT f)
forall a b c d e f. ((a, b), (c, d), (e, f)) -> (a, b, c, d, e, f)
to6 (((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d),
(ToMaybeT e, ToMaybeT f))
-> (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d, ToMaybeT e,
ToMaybeT f))
-> ((a, b, c, d, e, f)
-> ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d),
(ToMaybeT e, ToMaybeT f)))
-> (a, b, c, d, e, f)
-> (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d, ToMaybeT e,
ToMaybeT f)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((a, b), (c, d), (e, f))
-> ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d),
(ToMaybeT e, ToMaybeT f))
forall a. ToMaybe a => a -> ToMaybeT a
toMaybe (((a, b), (c, d), (e, f))
-> ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d),
(ToMaybeT e, ToMaybeT f)))
-> ((a, b, c, d, e, f) -> ((a, b), (c, d), (e, f)))
-> (a, b, c, d, e, f)
-> ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d),
(ToMaybeT e, ToMaybeT f))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, b, c, d, e, f) -> ((a, b), (c, d), (e, f))
forall a b c d e f. (a, b, c, d, e, f) -> ((a, b), (c, d), (e, f))
from6
instance ( ToMaybe a
, ToMaybe b
, ToMaybe c
, ToMaybe d
, ToMaybe e
, ToMaybe f
, ToMaybe g
) => ToMaybe (a,b,c,d,e,f,g) where
type ToMaybeT (a, b, c, d, e, f, g) = (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d, ToMaybeT e, ToMaybeT f, ToMaybeT g)
toMaybe :: (a, b, c, d, e, f, g) -> ToMaybeT (a, b, c, d, e, f, g)
toMaybe = ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d),
(ToMaybeT e, ToMaybeT f), ToMaybeT g)
-> (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d, ToMaybeT e,
ToMaybeT f, ToMaybeT g)
forall a b c d e f g.
((a, b), (c, d), (e, f), g) -> (a, b, c, d, e, f, g)
to7 (((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d),
(ToMaybeT e, ToMaybeT f), ToMaybeT g)
-> (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d, ToMaybeT e,
ToMaybeT f, ToMaybeT g))
-> ((a, b, c, d, e, f, g)
-> ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d),
(ToMaybeT e, ToMaybeT f), ToMaybeT g))
-> (a, b, c, d, e, f, g)
-> (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d, ToMaybeT e,
ToMaybeT f, ToMaybeT g)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((a, b), (c, d), (e, f), g)
-> ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d),
(ToMaybeT e, ToMaybeT f), ToMaybeT g)
forall a. ToMaybe a => a -> ToMaybeT a
toMaybe (((a, b), (c, d), (e, f), g)
-> ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d),
(ToMaybeT e, ToMaybeT f), ToMaybeT g))
-> ((a, b, c, d, e, f, g) -> ((a, b), (c, d), (e, f), g))
-> (a, b, c, d, e, f, g)
-> ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d),
(ToMaybeT e, ToMaybeT f), ToMaybeT g)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, b, c, d, e, f, g) -> ((a, b), (c, d), (e, f), g)
forall a b c d e f g.
(a, b, c, d, e, f, g) -> ((a, b), (c, d), (e, f), g)
from7
instance ( ToMaybe a
, ToMaybe b
, ToMaybe c
, ToMaybe d
, ToMaybe e
, ToMaybe f
, ToMaybe g
, ToMaybe h
) => ToMaybe (a,b,c,d,e,f,g,h) where
type ToMaybeT (a, b, c, d, e, f, g, h) = (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d, ToMaybeT e, ToMaybeT f, ToMaybeT g, ToMaybeT h)
toMaybe :: (a, b, c, d, e, f, g, h) -> ToMaybeT (a, b, c, d, e, f, g, h)
toMaybe = ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d),
(ToMaybeT e, ToMaybeT f), (ToMaybeT g, ToMaybeT h))
-> (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d, ToMaybeT e,
ToMaybeT f, ToMaybeT g, ToMaybeT h)
forall a b c d e f g h.
((a, b), (c, d), (e, f), (g, h)) -> (a, b, c, d, e, f, g, h)
to8 (((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d),
(ToMaybeT e, ToMaybeT f), (ToMaybeT g, ToMaybeT h))
-> (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d, ToMaybeT e,
ToMaybeT f, ToMaybeT g, ToMaybeT h))
-> ((a, b, c, d, e, f, g, h)
-> ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d),
(ToMaybeT e, ToMaybeT f), (ToMaybeT g, ToMaybeT h)))
-> (a, b, c, d, e, f, g, h)
-> (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d, ToMaybeT e,
ToMaybeT f, ToMaybeT g, ToMaybeT h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((a, b), (c, d), (e, f), (g, h))
-> ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d),
(ToMaybeT e, ToMaybeT f), (ToMaybeT g, ToMaybeT h))
forall a. ToMaybe a => a -> ToMaybeT a
toMaybe (((a, b), (c, d), (e, f), (g, h))
-> ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d),
(ToMaybeT e, ToMaybeT f), (ToMaybeT g, ToMaybeT h)))
-> ((a, b, c, d, e, f, g, h) -> ((a, b), (c, d), (e, f), (g, h)))
-> (a, b, c, d, e, f, g, h)
-> ((ToMaybeT a, ToMaybeT b), (ToMaybeT c, ToMaybeT d),
(ToMaybeT e, ToMaybeT f), (ToMaybeT g, ToMaybeT h))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, b, c, d, e, f, g, h) -> ((a, b), (c, d), (e, f), (g, h))
forall a b c d e f g h.
(a, b, c, d, e, f, g, h) -> ((a, b), (c, d), (e, f), (g, h))
from8
from :: ToFrom a => a -> SqlQuery (ToFromT a)
from :: a -> SqlQuery (ToFromT a)
from a
parts = do
(ToFromT a
a, FromClause
clause) <- From (ToFromT a) -> SqlQuery (ToFromT a, FromClause)
forall a. From a -> SqlQuery (a, FromClause)
runFrom (From (ToFromT a) -> SqlQuery (ToFromT a, FromClause))
-> From (ToFromT a) -> SqlQuery (ToFromT a, FromClause)
forall a b. (a -> b) -> a -> b
$ a -> From (ToFromT a)
forall a. ToFrom a => a -> From (ToFromT a)
toFrom a
parts
WriterT SideData (State IdentState) () -> SqlQuery ()
forall a. WriterT SideData (State IdentState) a -> SqlQuery a
Q (WriterT SideData (State IdentState) () -> SqlQuery ())
-> WriterT SideData (State IdentState) () -> SqlQuery ()
forall a b. (a -> b) -> a -> b
$ SideData -> WriterT SideData (State IdentState) ()
forall (m :: * -> *) w. Monad m => w -> WriterT w m ()
W.tell SideData
forall a. Monoid a => a
mempty{sdFromClause :: [FromClause]
sdFromClause=[FromClause
clause]}
ToFromT a -> SqlQuery (ToFromT a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ToFromT a
a
where
runFrom :: From a -> SqlQuery (a, FromClause)
runFrom :: From a -> SqlQuery (a, FromClause)
runFrom e :: From a
e@From a
Table = do
let ed :: EntityDef
ed = Proxy ent -> EntityDef
forall record (proxy :: * -> *).
PersistEntity record =>
proxy record -> EntityDef
entityDef (Proxy ent -> EntityDef) -> Proxy ent -> EntityDef
forall a b. (a -> b) -> a -> b
$ From (SqlExpr (Entity ent)) -> Proxy ent
forall ent. From (SqlExpr (Entity ent)) -> Proxy ent
getVal From a
From (SqlExpr (Entity ent))
e
Ident
ident <- DBName -> SqlQuery Ident
newIdentFor (EntityDef -> DBName
entityDB EntityDef
ed)
let entity :: SqlExpr (Entity ent)
entity = Ident -> SqlExpr (Entity ent)
forall val. Ident -> SqlExpr (Entity val)
EEntity Ident
ident
(SqlExpr (Entity ent), FromClause)
-> SqlQuery (SqlExpr (Entity ent), FromClause)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((SqlExpr (Entity ent), FromClause)
-> SqlQuery (SqlExpr (Entity ent), FromClause))
-> (SqlExpr (Entity ent), FromClause)
-> SqlQuery (SqlExpr (Entity ent), FromClause)
forall a b. (a -> b) -> a -> b
$ (SqlExpr (Entity ent)
entity, Ident -> EntityDef -> FromClause
FromStart Ident
ident EntityDef
ed)
where
getVal :: From (SqlExpr (Entity ent)) -> Proxy ent
getVal :: From (SqlExpr (Entity ent)) -> Proxy ent
getVal = Proxy ent -> From (SqlExpr (Entity ent)) -> Proxy ent
forall a b. a -> b -> a
const Proxy ent
forall k (t :: k). Proxy t
Proxy
runFrom (SubQuery SqlQuery a
subquery) =
SubQueryType -> SqlQuery a -> SqlQuery (a, FromClause)
forall a r.
(SqlSelect a r, ToAlias a, ToAliasReference a) =>
SubQueryType -> SqlQuery a -> SqlQuery (a, FromClause)
fromSubQuery SubQueryType
NormalSubQuery SqlQuery a
subquery
runFrom (FromCte Ident
ident a
ref) =
(a, FromClause) -> SqlQuery (a, FromClause)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a
ref, Ident -> FromClause
FromIdent Ident
ident)
runFrom (SqlSetOperation SqlSetOperation a
operation) = do
(SqlSetOperation a
aliasedOperation, a
ret) <- SqlSetOperation a -> SqlQuery (SqlSetOperation a, a)
forall b.
ToAlias b =>
SqlSetOperation b -> SqlQuery (SqlSetOperation b, b)
aliasQueries SqlSetOperation a
operation
Ident
ident <- DBName -> SqlQuery Ident
newIdentFor (Text -> DBName
DBName Text
"u")
a
ref <- Ident -> a -> SqlQuery a
forall a. ToAliasReference a => Ident -> a -> SqlQuery a
toAliasReference Ident
ident a
ret
(a, FromClause) -> SqlQuery (a, FromClause)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a
ref, Ident
-> (IdentInfo -> (Builder, [PersistValue]))
-> SubQueryType
-> FromClause
FromQuery Ident
ident (SqlSetOperation a -> IdentInfo -> (Builder, [PersistValue])
forall a r backend.
(SqlSelect a r, BackendCompatible SqlBackend backend) =>
SqlSetOperation a
-> (backend, IdentState) -> (Builder, [PersistValue])
operationToSql SqlSetOperation a
aliasedOperation) SubQueryType
NormalSubQuery)
where
aliasQueries :: SqlSetOperation b -> SqlQuery (SqlSetOperation b, b)
aliasQueries SqlSetOperation b
o =
case SqlSetOperation b
o of
SelectQueryP NeedParens
p SqlQuery b
q -> do
(b
ret, SideData
sideData) <- WriterT SideData (State IdentState) (b, SideData)
-> SqlQuery (b, SideData)
forall a. WriterT SideData (State IdentState) a -> SqlQuery a
Q (WriterT SideData (State IdentState) (b, SideData)
-> SqlQuery (b, SideData))
-> WriterT SideData (State IdentState) (b, SideData)
-> SqlQuery (b, SideData)
forall a b. (a -> b) -> a -> b
$ (SideData -> SideData)
-> WriterT SideData (State IdentState) (b, SideData)
-> WriterT SideData (State IdentState) (b, SideData)
forall (m :: * -> *) w a.
Monad m =>
(w -> w) -> WriterT w m a -> WriterT w m a
W.censor (\SideData
_ -> SideData
forall a. Monoid a => a
mempty) (WriterT SideData (State IdentState) (b, SideData)
-> WriterT SideData (State IdentState) (b, SideData))
-> WriterT SideData (State IdentState) (b, SideData)
-> WriterT SideData (State IdentState) (b, SideData)
forall a b. (a -> b) -> a -> b
$ WriterT SideData (State IdentState) b
-> WriterT SideData (State IdentState) (b, SideData)
forall (m :: * -> *) w a.
Monad m =>
WriterT w m a -> WriterT w m (a, w)
W.listen (WriterT SideData (State IdentState) b
-> WriterT SideData (State IdentState) (b, SideData))
-> WriterT SideData (State IdentState) b
-> WriterT SideData (State IdentState) (b, SideData)
forall a b. (a -> b) -> a -> b
$ SqlQuery b -> WriterT SideData (State IdentState) b
forall a. SqlQuery a -> WriterT SideData (State IdentState) a
unQ SqlQuery b
q
IdentState
prevState <- WriterT SideData (State IdentState) IdentState
-> SqlQuery IdentState
forall a. WriterT SideData (State IdentState) a -> SqlQuery a
Q (WriterT SideData (State IdentState) IdentState
-> SqlQuery IdentState)
-> WriterT SideData (State IdentState) IdentState
-> SqlQuery IdentState
forall a b. (a -> b) -> a -> b
$ StateT IdentState Identity IdentState
-> WriterT SideData (State IdentState) IdentState
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift StateT IdentState Identity IdentState
forall (m :: * -> *) s. Monad m => StateT s m s
S.get
b
aliasedRet <- b -> SqlQuery b
forall a. ToAlias a => a -> SqlQuery a
toAlias b
ret
WriterT SideData (State IdentState) () -> SqlQuery ()
forall a. WriterT SideData (State IdentState) a -> SqlQuery a
Q (WriterT SideData (State IdentState) () -> SqlQuery ())
-> WriterT SideData (State IdentState) () -> SqlQuery ()
forall a b. (a -> b) -> a -> b
$ StateT IdentState Identity ()
-> WriterT SideData (State IdentState) ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (StateT IdentState Identity ()
-> WriterT SideData (State IdentState) ())
-> StateT IdentState Identity ()
-> WriterT SideData (State IdentState) ()
forall a b. (a -> b) -> a -> b
$ IdentState -> StateT IdentState Identity ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
S.put IdentState
prevState
let p' :: NeedParens
p' =
case NeedParens
p of
NeedParens
Parens -> NeedParens
Parens
NeedParens
Never ->
if (SideData -> LimitClause
sdLimitClause SideData
sideData) LimitClause -> LimitClause -> Bool
forall a. Eq a => a -> a -> Bool
/= LimitClause
forall a. Monoid a => a
mempty
Bool -> Bool -> Bool
|| [OrderByClause] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (SideData -> [OrderByClause]
sdOrderByClause SideData
sideData) Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0 then
NeedParens
Parens
else
NeedParens
Never
(SqlSetOperation b, b) -> SqlQuery (SqlSetOperation b, b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (NeedParens -> SqlQuery b -> SqlSetOperation b
forall a. NeedParens -> SqlQuery a -> SqlSetOperation a
SelectQueryP NeedParens
p' (SqlQuery b -> SqlSetOperation b)
-> SqlQuery b -> SqlSetOperation b
forall a b. (a -> b) -> a -> b
$ WriterT SideData (State IdentState) b -> SqlQuery b
forall a. WriterT SideData (State IdentState) a -> SqlQuery a
Q (WriterT SideData (State IdentState) b -> SqlQuery b)
-> WriterT SideData (State IdentState) b -> SqlQuery b
forall a b. (a -> b) -> a -> b
$ State IdentState (b, SideData)
-> WriterT SideData (State IdentState) b
forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
W.WriterT (State IdentState (b, SideData)
-> WriterT SideData (State IdentState) b)
-> State IdentState (b, SideData)
-> WriterT SideData (State IdentState) b
forall a b. (a -> b) -> a -> b
$ (b, SideData) -> State IdentState (b, SideData)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (b
aliasedRet, SideData
sideData), b
aliasedRet)
SqlSetUnion SqlSetOperation b
o1 SqlSetOperation b
o2 -> do
(SqlSetOperation b
o1', b
ret) <- SqlSetOperation b -> SqlQuery (SqlSetOperation b, b)
aliasQueries SqlSetOperation b
o1
(SqlSetOperation b
o2', b
_ ) <- SqlSetOperation b -> SqlQuery (SqlSetOperation b, b)
aliasQueries SqlSetOperation b
o2
(SqlSetOperation b, b) -> SqlQuery (SqlSetOperation b, b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SqlSetOperation b -> SqlSetOperation b -> SqlSetOperation b
forall a.
SqlSetOperation a -> SqlSetOperation a -> SqlSetOperation a
SqlSetUnion SqlSetOperation b
o1' SqlSetOperation b
o2', b
ret)
SqlSetUnionAll SqlSetOperation b
o1 SqlSetOperation b
o2 -> do
(SqlSetOperation b
o1', b
ret) <- SqlSetOperation b -> SqlQuery (SqlSetOperation b, b)
aliasQueries SqlSetOperation b
o1
(SqlSetOperation b
o2', b
_ ) <- SqlSetOperation b -> SqlQuery (SqlSetOperation b, b)
aliasQueries SqlSetOperation b
o2
(SqlSetOperation b, b) -> SqlQuery (SqlSetOperation b, b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SqlSetOperation b -> SqlSetOperation b -> SqlSetOperation b
forall a.
SqlSetOperation a -> SqlSetOperation a -> SqlSetOperation a
SqlSetUnionAll SqlSetOperation b
o1' SqlSetOperation b
o2', b
ret)
SqlSetExcept SqlSetOperation b
o1 SqlSetOperation b
o2 -> do
(SqlSetOperation b
o1', b
ret) <- SqlSetOperation b -> SqlQuery (SqlSetOperation b, b)
aliasQueries SqlSetOperation b
o1
(SqlSetOperation b
o2', b
_ ) <- SqlSetOperation b -> SqlQuery (SqlSetOperation b, b)
aliasQueries SqlSetOperation b
o2
(SqlSetOperation b, b) -> SqlQuery (SqlSetOperation b, b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SqlSetOperation b -> SqlSetOperation b -> SqlSetOperation b
forall a.
SqlSetOperation a -> SqlSetOperation a -> SqlSetOperation a
SqlSetExcept SqlSetOperation b
o1' SqlSetOperation b
o2', b
ret)
SqlSetIntersect SqlSetOperation b
o1 SqlSetOperation b
o2 -> do
(SqlSetOperation b
o1', b
ret) <- SqlSetOperation b -> SqlQuery (SqlSetOperation b, b)
aliasQueries SqlSetOperation b
o1
(SqlSetOperation b
o2', b
_ ) <- SqlSetOperation b -> SqlQuery (SqlSetOperation b, b)
aliasQueries SqlSetOperation b
o2
(SqlSetOperation b, b) -> SqlQuery (SqlSetOperation b, b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SqlSetOperation b -> SqlSetOperation b -> SqlSetOperation b
forall a.
SqlSetOperation a -> SqlSetOperation a -> SqlSetOperation a
SqlSetIntersect SqlSetOperation b
o1' SqlSetOperation b
o2', b
ret)
operationToSql :: SqlSetOperation a
-> (backend, IdentState) -> (Builder, [PersistValue])
operationToSql SqlSetOperation a
o (backend, IdentState)
info =
case SqlSetOperation a
o of
SelectQueryP NeedParens
p SqlQuery a
q ->
let (Builder
builder, [PersistValue]
values) = Mode
-> (backend, IdentState) -> SqlQuery a -> (Builder, [PersistValue])
forall a r backend.
(SqlSelect a r, BackendCompatible SqlBackend backend) =>
Mode
-> (backend, IdentState) -> SqlQuery a -> (Builder, [PersistValue])
toRawSql Mode
SELECT (backend, IdentState)
info SqlQuery a
q
in (NeedParens -> Builder -> Builder
parensM NeedParens
p Builder
builder, [PersistValue]
values)
SqlSetUnion SqlSetOperation a
o1 SqlSetOperation a
o2 -> Builder
-> (backend, IdentState)
-> SqlSetOperation a
-> SqlSetOperation a
-> (Builder, [PersistValue])
doSetOperation Builder
"UNION" (backend, IdentState)
info SqlSetOperation a
o1 SqlSetOperation a
o2
SqlSetUnionAll SqlSetOperation a
o1 SqlSetOperation a
o2 -> Builder
-> (backend, IdentState)
-> SqlSetOperation a
-> SqlSetOperation a
-> (Builder, [PersistValue])
doSetOperation Builder
"UNION ALL" (backend, IdentState)
info SqlSetOperation a
o1 SqlSetOperation a
o2
SqlSetExcept SqlSetOperation a
o1 SqlSetOperation a
o2 -> Builder
-> (backend, IdentState)
-> SqlSetOperation a
-> SqlSetOperation a
-> (Builder, [PersistValue])
doSetOperation Builder
"EXCEPT" (backend, IdentState)
info SqlSetOperation a
o1 SqlSetOperation a
o2
SqlSetIntersect SqlSetOperation a
o1 SqlSetOperation a
o2 -> Builder
-> (backend, IdentState)
-> SqlSetOperation a
-> SqlSetOperation a
-> (Builder, [PersistValue])
doSetOperation Builder
"INTERSECT" (backend, IdentState)
info SqlSetOperation a
o1 SqlSetOperation a
o2
doSetOperation :: Builder
-> (backend, IdentState)
-> SqlSetOperation a
-> SqlSetOperation a
-> (Builder, [PersistValue])
doSetOperation Builder
operationText (backend, IdentState)
info SqlSetOperation a
o1 SqlSetOperation a
o2 =
let (Builder
q1, [PersistValue]
v1) = SqlSetOperation a
-> (backend, IdentState) -> (Builder, [PersistValue])
operationToSql SqlSetOperation a
o1 (backend, IdentState)
info
(Builder
q2, [PersistValue]
v2) = SqlSetOperation a
-> (backend, IdentState) -> (Builder, [PersistValue])
operationToSql SqlSetOperation a
o2 (backend, IdentState)
info
in (Builder
q1 Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
" " Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
operationText Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
" " Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
q2, [PersistValue]
v1 [PersistValue] -> [PersistValue] -> [PersistValue]
forall a. Semigroup a => a -> a -> a
<> [PersistValue]
v2)
runFrom (InnerJoinFrom From a
leftPart (From b
rightPart, (a :& b) -> SqlExpr (Value Bool)
on')) = do
(a
leftVal, FromClause
leftFrom) <- From a -> SqlQuery (a, FromClause)
forall a. From a -> SqlQuery (a, FromClause)
runFrom From a
leftPart
(b
rightVal, FromClause
rightFrom) <- From b -> SqlQuery (b, FromClause)
forall a. From a -> SqlQuery (a, FromClause)
runFrom From b
rightPart
let ret :: a :& b
ret = a
leftVal a -> b -> a :& b
forall a b. a -> b -> a :& b
:& b
rightVal
(a :& b, FromClause) -> SqlQuery (a :& b, FromClause)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((a :& b, FromClause) -> SqlQuery (a :& b, FromClause))
-> (a :& b, FromClause) -> SqlQuery (a :& b, FromClause)
forall a b. (a -> b) -> a -> b
$ (a :& b
ret, FromClause
-> JoinKind
-> FromClause
-> Maybe (SqlExpr (Value Bool))
-> FromClause
FromJoin FromClause
leftFrom JoinKind
InnerJoinKind FromClause
rightFrom (SqlExpr (Value Bool) -> Maybe (SqlExpr (Value Bool))
forall a. a -> Maybe a
Just ((a :& b) -> SqlExpr (Value Bool)
on' a :& b
ret)))
runFrom (InnerJoinFromLateral From a
leftPart (a -> SqlQuery b
q, (a :& b) -> SqlExpr (Value Bool)
on')) = do
(a
leftVal, FromClause
leftFrom) <- From a -> SqlQuery (a, FromClause)
forall a. From a -> SqlQuery (a, FromClause)
runFrom From a
leftPart
(b
rightVal, FromClause
rightFrom) <- SubQueryType -> SqlQuery b -> SqlQuery (b, FromClause)
forall a r.
(SqlSelect a r, ToAlias a, ToAliasReference a) =>
SubQueryType -> SqlQuery a -> SqlQuery (a, FromClause)
fromSubQuery SubQueryType
LateralSubQuery (a -> SqlQuery b
q a
leftVal)
let ret :: a :& b
ret = a
leftVal a -> b -> a :& b
forall a b. a -> b -> a :& b
:& b
rightVal
(a :& b, FromClause) -> SqlQuery (a :& b, FromClause)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((a :& b, FromClause) -> SqlQuery (a :& b, FromClause))
-> (a :& b, FromClause) -> SqlQuery (a :& b, FromClause)
forall a b. (a -> b) -> a -> b
$ (a :& b
ret, FromClause
-> JoinKind
-> FromClause
-> Maybe (SqlExpr (Value Bool))
-> FromClause
FromJoin FromClause
leftFrom JoinKind
InnerJoinKind FromClause
rightFrom (SqlExpr (Value Bool) -> Maybe (SqlExpr (Value Bool))
forall a. a -> Maybe a
Just ((a :& b) -> SqlExpr (Value Bool)
on' a :& b
ret)))
runFrom (CrossJoinFrom From a
leftPart From b
rightPart) = do
(a
leftVal, FromClause
leftFrom) <- From a -> SqlQuery (a, FromClause)
forall a. From a -> SqlQuery (a, FromClause)
runFrom From a
leftPart
(b
rightVal, FromClause
rightFrom) <- From b -> SqlQuery (b, FromClause)
forall a. From a -> SqlQuery (a, FromClause)
runFrom From b
rightPart
let ret :: a :& b
ret = a
leftVal a -> b -> a :& b
forall a b. a -> b -> a :& b
:& b
rightVal
(a :& b, FromClause) -> SqlQuery (a :& b, FromClause)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((a :& b, FromClause) -> SqlQuery (a :& b, FromClause))
-> (a :& b, FromClause) -> SqlQuery (a :& b, FromClause)
forall a b. (a -> b) -> a -> b
$ (a :& b
ret, FromClause
-> JoinKind
-> FromClause
-> Maybe (SqlExpr (Value Bool))
-> FromClause
FromJoin FromClause
leftFrom JoinKind
CrossJoinKind FromClause
rightFrom Maybe (SqlExpr (Value Bool))
forall a. Maybe a
Nothing)
runFrom (CrossJoinFromLateral From a
leftPart a -> SqlQuery b
q) = do
(a
leftVal, FromClause
leftFrom) <- From a -> SqlQuery (a, FromClause)
forall a. From a -> SqlQuery (a, FromClause)
runFrom From a
leftPart
(b
rightVal, FromClause
rightFrom) <- SubQueryType -> SqlQuery b -> SqlQuery (b, FromClause)
forall a r.
(SqlSelect a r, ToAlias a, ToAliasReference a) =>
SubQueryType -> SqlQuery a -> SqlQuery (a, FromClause)
fromSubQuery SubQueryType
LateralSubQuery (a -> SqlQuery b
q a
leftVal)
let ret :: a :& b
ret = a
leftVal a -> b -> a :& b
forall a b. a -> b -> a :& b
:& b
rightVal
(a :& b, FromClause) -> SqlQuery (a :& b, FromClause)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((a :& b, FromClause) -> SqlQuery (a :& b, FromClause))
-> (a :& b, FromClause) -> SqlQuery (a :& b, FromClause)
forall a b. (a -> b) -> a -> b
$ (a :& b
ret, FromClause
-> JoinKind
-> FromClause
-> Maybe (SqlExpr (Value Bool))
-> FromClause
FromJoin FromClause
leftFrom JoinKind
CrossJoinKind FromClause
rightFrom Maybe (SqlExpr (Value Bool))
forall a. Maybe a
Nothing)
runFrom (LeftJoinFrom From a
leftPart (From b
rightPart, (a :& ToMaybeT b) -> SqlExpr (Value Bool)
on')) = do
(a
leftVal, FromClause
leftFrom) <- From a -> SqlQuery (a, FromClause)
forall a. From a -> SqlQuery (a, FromClause)
runFrom From a
leftPart
(b
rightVal, FromClause
rightFrom) <- From b -> SqlQuery (b, FromClause)
forall a. From a -> SqlQuery (a, FromClause)
runFrom From b
rightPart
let ret :: a :& ToMaybeT b
ret = a
leftVal a -> ToMaybeT b -> a :& ToMaybeT b
forall a b. a -> b -> a :& b
:& (b -> ToMaybeT b
forall a. ToMaybe a => a -> ToMaybeT a
toMaybe b
rightVal)
(a :& ToMaybeT b, FromClause)
-> SqlQuery (a :& ToMaybeT b, FromClause)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((a :& ToMaybeT b, FromClause)
-> SqlQuery (a :& ToMaybeT b, FromClause))
-> (a :& ToMaybeT b, FromClause)
-> SqlQuery (a :& ToMaybeT b, FromClause)
forall a b. (a -> b) -> a -> b
$ (a :& ToMaybeT b
ret, FromClause
-> JoinKind
-> FromClause
-> Maybe (SqlExpr (Value Bool))
-> FromClause
FromJoin FromClause
leftFrom JoinKind
LeftOuterJoinKind FromClause
rightFrom (SqlExpr (Value Bool) -> Maybe (SqlExpr (Value Bool))
forall a. a -> Maybe a
Just ((a :& ToMaybeT b) -> SqlExpr (Value Bool)
on' a :& ToMaybeT b
ret)))
runFrom (LeftJoinFromLateral From a
leftPart (a -> SqlQuery b
q, (a :& ToMaybeT b) -> SqlExpr (Value Bool)
on')) = do
(a
leftVal, FromClause
leftFrom) <- From a -> SqlQuery (a, FromClause)
forall a. From a -> SqlQuery (a, FromClause)
runFrom From a
leftPart
(b
rightVal, FromClause
rightFrom) <- SubQueryType -> SqlQuery b -> SqlQuery (b, FromClause)
forall a r.
(SqlSelect a r, ToAlias a, ToAliasReference a) =>
SubQueryType -> SqlQuery a -> SqlQuery (a, FromClause)
fromSubQuery SubQueryType
LateralSubQuery (a -> SqlQuery b
q a
leftVal)
let ret :: a :& ToMaybeT b
ret = a
leftVal a -> ToMaybeT b -> a :& ToMaybeT b
forall a b. a -> b -> a :& b
:& (b -> ToMaybeT b
forall a. ToMaybe a => a -> ToMaybeT a
toMaybe b
rightVal)
(a :& ToMaybeT b, FromClause)
-> SqlQuery (a :& ToMaybeT b, FromClause)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((a :& ToMaybeT b, FromClause)
-> SqlQuery (a :& ToMaybeT b, FromClause))
-> (a :& ToMaybeT b, FromClause)
-> SqlQuery (a :& ToMaybeT b, FromClause)
forall a b. (a -> b) -> a -> b
$ (a :& ToMaybeT b
ret, FromClause
-> JoinKind
-> FromClause
-> Maybe (SqlExpr (Value Bool))
-> FromClause
FromJoin FromClause
leftFrom JoinKind
LeftOuterJoinKind FromClause
rightFrom (SqlExpr (Value Bool) -> Maybe (SqlExpr (Value Bool))
forall a. a -> Maybe a
Just ((a :& ToMaybeT b) -> SqlExpr (Value Bool)
on' a :& ToMaybeT b
ret)))
runFrom (RightJoinFrom From a
leftPart (From b
rightPart, (ToMaybeT a :& b) -> SqlExpr (Value Bool)
on')) = do
(a
leftVal, FromClause
leftFrom) <- From a -> SqlQuery (a, FromClause)
forall a. From a -> SqlQuery (a, FromClause)
runFrom From a
leftPart
(b
rightVal, FromClause
rightFrom) <- From b -> SqlQuery (b, FromClause)
forall a. From a -> SqlQuery (a, FromClause)
runFrom From b
rightPart
let ret :: ToMaybeT a :& b
ret = (a -> ToMaybeT a
forall a. ToMaybe a => a -> ToMaybeT a
toMaybe a
leftVal) ToMaybeT a -> b -> ToMaybeT a :& b
forall a b. a -> b -> a :& b
:& b
rightVal
(ToMaybeT a :& b, FromClause)
-> SqlQuery (ToMaybeT a :& b, FromClause)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((ToMaybeT a :& b, FromClause)
-> SqlQuery (ToMaybeT a :& b, FromClause))
-> (ToMaybeT a :& b, FromClause)
-> SqlQuery (ToMaybeT a :& b, FromClause)
forall a b. (a -> b) -> a -> b
$ (ToMaybeT a :& b
ret, FromClause
-> JoinKind
-> FromClause
-> Maybe (SqlExpr (Value Bool))
-> FromClause
FromJoin FromClause
leftFrom JoinKind
RightOuterJoinKind FromClause
rightFrom (SqlExpr (Value Bool) -> Maybe (SqlExpr (Value Bool))
forall a. a -> Maybe a
Just ((ToMaybeT a :& b) -> SqlExpr (Value Bool)
on' ToMaybeT a :& b
ret)))
runFrom (FullJoinFrom From a
leftPart (From b
rightPart, (ToMaybeT a :& ToMaybeT b) -> SqlExpr (Value Bool)
on')) = do
(a
leftVal, FromClause
leftFrom) <- From a -> SqlQuery (a, FromClause)
forall a. From a -> SqlQuery (a, FromClause)
runFrom From a
leftPart
(b
rightVal, FromClause
rightFrom) <- From b -> SqlQuery (b, FromClause)
forall a. From a -> SqlQuery (a, FromClause)
runFrom From b
rightPart
let ret :: ToMaybeT a :& ToMaybeT b
ret = (a -> ToMaybeT a
forall a. ToMaybe a => a -> ToMaybeT a
toMaybe a
leftVal) ToMaybeT a -> ToMaybeT b -> ToMaybeT a :& ToMaybeT b
forall a b. a -> b -> a :& b
:& (b -> ToMaybeT b
forall a. ToMaybe a => a -> ToMaybeT a
toMaybe b
rightVal)
(ToMaybeT a :& ToMaybeT b, FromClause)
-> SqlQuery (ToMaybeT a :& ToMaybeT b, FromClause)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((ToMaybeT a :& ToMaybeT b, FromClause)
-> SqlQuery (ToMaybeT a :& ToMaybeT b, FromClause))
-> (ToMaybeT a :& ToMaybeT b, FromClause)
-> SqlQuery (ToMaybeT a :& ToMaybeT b, FromClause)
forall a b. (a -> b) -> a -> b
$ (ToMaybeT a :& ToMaybeT b
ret, FromClause
-> JoinKind
-> FromClause
-> Maybe (SqlExpr (Value Bool))
-> FromClause
FromJoin FromClause
leftFrom JoinKind
FullOuterJoinKind FromClause
rightFrom (SqlExpr (Value Bool) -> Maybe (SqlExpr (Value Bool))
forall a. a -> Maybe a
Just ((ToMaybeT a :& ToMaybeT b) -> SqlExpr (Value Bool)
on' ToMaybeT a :& ToMaybeT b
ret)))
fromSubQuery
::
( SqlSelect a r
, ToAlias a
, ToAliasReference a
)
=> SubQueryType -> SqlQuery a -> SqlQuery (a, FromClause)
fromSubQuery :: SubQueryType -> SqlQuery a -> SqlQuery (a, FromClause)
fromSubQuery SubQueryType
subqueryType SqlQuery a
subquery = do
(a
ret, SideData
sideData) <- WriterT SideData (State IdentState) (a, SideData)
-> SqlQuery (a, SideData)
forall a. WriterT SideData (State IdentState) a -> SqlQuery a
Q (WriterT SideData (State IdentState) (a, SideData)
-> SqlQuery (a, SideData))
-> WriterT SideData (State IdentState) (a, SideData)
-> SqlQuery (a, SideData)
forall a b. (a -> b) -> a -> b
$ (SideData -> SideData)
-> WriterT SideData (State IdentState) (a, SideData)
-> WriterT SideData (State IdentState) (a, SideData)
forall (m :: * -> *) w a.
Monad m =>
(w -> w) -> WriterT w m a -> WriterT w m a
W.censor (\SideData
_ -> SideData
forall a. Monoid a => a
mempty) (WriterT SideData (State IdentState) (a, SideData)
-> WriterT SideData (State IdentState) (a, SideData))
-> WriterT SideData (State IdentState) (a, SideData)
-> WriterT SideData (State IdentState) (a, SideData)
forall a b. (a -> b) -> a -> b
$ WriterT SideData (State IdentState) a
-> WriterT SideData (State IdentState) (a, SideData)
forall (m :: * -> *) w a.
Monad m =>
WriterT w m a -> WriterT w m (a, w)
W.listen (WriterT SideData (State IdentState) a
-> WriterT SideData (State IdentState) (a, SideData))
-> WriterT SideData (State IdentState) a
-> WriterT SideData (State IdentState) (a, SideData)
forall a b. (a -> b) -> a -> b
$ SqlQuery a -> WriterT SideData (State IdentState) a
forall a. SqlQuery a -> WriterT SideData (State IdentState) a
unQ SqlQuery a
subquery
a
aliasedValue <- a -> SqlQuery a
forall a. ToAlias a => a -> SqlQuery a
toAlias a
ret
let aliasedQuery :: SqlQuery a
aliasedQuery = WriterT SideData (State IdentState) a -> SqlQuery a
forall a. WriterT SideData (State IdentState) a -> SqlQuery a
Q (WriterT SideData (State IdentState) a -> SqlQuery a)
-> WriterT SideData (State IdentState) a -> SqlQuery a
forall a b. (a -> b) -> a -> b
$ State IdentState (a, SideData)
-> WriterT SideData (State IdentState) a
forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
W.WriterT (State IdentState (a, SideData)
-> WriterT SideData (State IdentState) a)
-> State IdentState (a, SideData)
-> WriterT SideData (State IdentState) a
forall a b. (a -> b) -> a -> b
$ (a, SideData) -> State IdentState (a, SideData)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a
aliasedValue, SideData
sideData)
Ident
subqueryAlias <- DBName -> SqlQuery Ident
newIdentFor (Text -> DBName
DBName Text
"q")
a
ref <- Ident -> a -> SqlQuery a
forall a. ToAliasReference a => Ident -> a -> SqlQuery a
toAliasReference Ident
subqueryAlias a
aliasedValue
(a, FromClause) -> SqlQuery (a, FromClause)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a
ref , Ident
-> (IdentInfo -> (Builder, [PersistValue]))
-> SubQueryType
-> FromClause
FromQuery Ident
subqueryAlias (\IdentInfo
info -> Mode -> IdentInfo -> SqlQuery a -> (Builder, [PersistValue])
forall a r backend.
(SqlSelect a r, BackendCompatible SqlBackend backend) =>
Mode
-> (backend, IdentState) -> SqlQuery a -> (Builder, [PersistValue])
toRawSql Mode
SELECT IdentInfo
info SqlQuery a
aliasedQuery) SubQueryType
subqueryType)
with :: ( ToAlias a
, ToAliasReference a
, SqlSelect a r
) => SqlQuery a -> SqlQuery (From a)
with :: SqlQuery a -> SqlQuery (From a)
with SqlQuery a
query = do
(a
ret, SideData
sideData) <- WriterT SideData (State IdentState) (a, SideData)
-> SqlQuery (a, SideData)
forall a. WriterT SideData (State IdentState) a -> SqlQuery a
Q (WriterT SideData (State IdentState) (a, SideData)
-> SqlQuery (a, SideData))
-> WriterT SideData (State IdentState) (a, SideData)
-> SqlQuery (a, SideData)
forall a b. (a -> b) -> a -> b
$ (SideData -> SideData)
-> WriterT SideData (State IdentState) (a, SideData)
-> WriterT SideData (State IdentState) (a, SideData)
forall (m :: * -> *) w a.
Monad m =>
(w -> w) -> WriterT w m a -> WriterT w m a
W.censor (\SideData
_ -> SideData
forall a. Monoid a => a
mempty) (WriterT SideData (State IdentState) (a, SideData)
-> WriterT SideData (State IdentState) (a, SideData))
-> WriterT SideData (State IdentState) (a, SideData)
-> WriterT SideData (State IdentState) (a, SideData)
forall a b. (a -> b) -> a -> b
$ WriterT SideData (State IdentState) a
-> WriterT SideData (State IdentState) (a, SideData)
forall (m :: * -> *) w a.
Monad m =>
WriterT w m a -> WriterT w m (a, w)
W.listen (WriterT SideData (State IdentState) a
-> WriterT SideData (State IdentState) (a, SideData))
-> WriterT SideData (State IdentState) a
-> WriterT SideData (State IdentState) (a, SideData)
forall a b. (a -> b) -> a -> b
$ SqlQuery a -> WriterT SideData (State IdentState) a
forall a. SqlQuery a -> WriterT SideData (State IdentState) a
unQ SqlQuery a
query
a
aliasedValue <- a -> SqlQuery a
forall a. ToAlias a => a -> SqlQuery a
toAlias a
ret
let aliasedQuery :: SqlQuery a
aliasedQuery = WriterT SideData (State IdentState) a -> SqlQuery a
forall a. WriterT SideData (State IdentState) a -> SqlQuery a
Q (WriterT SideData (State IdentState) a -> SqlQuery a)
-> WriterT SideData (State IdentState) a -> SqlQuery a
forall a b. (a -> b) -> a -> b
$ State IdentState (a, SideData)
-> WriterT SideData (State IdentState) a
forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
W.WriterT (State IdentState (a, SideData)
-> WriterT SideData (State IdentState) a)
-> State IdentState (a, SideData)
-> WriterT SideData (State IdentState) a
forall a b. (a -> b) -> a -> b
$ (a, SideData) -> State IdentState (a, SideData)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a
aliasedValue, SideData
sideData)
Ident
ident <- DBName -> SqlQuery Ident
newIdentFor (Text -> DBName
DBName Text
"cte")
let clause :: CommonTableExpressionClause
clause = CommonTableExpressionKind
-> Ident
-> (IdentInfo -> (Builder, [PersistValue]))
-> CommonTableExpressionClause
CommonTableExpressionClause CommonTableExpressionKind
NormalCommonTableExpression Ident
ident (\IdentInfo
info -> Mode -> IdentInfo -> SqlQuery a -> (Builder, [PersistValue])
forall a r backend.
(SqlSelect a r, BackendCompatible SqlBackend backend) =>
Mode
-> (backend, IdentState) -> SqlQuery a -> (Builder, [PersistValue])
toRawSql Mode
SELECT IdentInfo
info SqlQuery a
aliasedQuery)
WriterT SideData (State IdentState) () -> SqlQuery ()
forall a. WriterT SideData (State IdentState) a -> SqlQuery a
Q (WriterT SideData (State IdentState) () -> SqlQuery ())
-> WriterT SideData (State IdentState) () -> SqlQuery ()
forall a b. (a -> b) -> a -> b
$ SideData -> WriterT SideData (State IdentState) ()
forall (m :: * -> *) w. Monad m => w -> WriterT w m ()
W.tell SideData
forall a. Monoid a => a
mempty{sdCteClause :: [CommonTableExpressionClause]
sdCteClause = [CommonTableExpressionClause
clause]}
a
ref <- Ident -> a -> SqlQuery a
forall a. ToAliasReference a => Ident -> a -> SqlQuery a
toAliasReference Ident
ident a
aliasedValue
From a -> SqlQuery (From a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (From a -> SqlQuery (From a)) -> From a -> SqlQuery (From a)
forall a b. (a -> b) -> a -> b
$ Ident -> a -> From a
forall a. Ident -> a -> From a
FromCte Ident
ident a
ref
withRecursive :: ( ToAlias a
, ToAliasReference a
, SqlSelect a r
, RecursiveCteUnion unionKind
)
=> SqlQuery a
-> unionKind
-> (From a -> SqlQuery a)
-> SqlQuery (From a)
withRecursive :: SqlQuery a
-> unionKind -> (From a -> SqlQuery a) -> SqlQuery (From a)
withRecursive SqlQuery a
baseCase unionKind
unionKind From a -> SqlQuery a
recursiveCase = do
(a
ret, SideData
sideData) <- WriterT SideData (State IdentState) (a, SideData)
-> SqlQuery (a, SideData)
forall a. WriterT SideData (State IdentState) a -> SqlQuery a
Q (WriterT SideData (State IdentState) (a, SideData)
-> SqlQuery (a, SideData))
-> WriterT SideData (State IdentState) (a, SideData)
-> SqlQuery (a, SideData)
forall a b. (a -> b) -> a -> b
$ (SideData -> SideData)
-> WriterT SideData (State IdentState) (a, SideData)
-> WriterT SideData (State IdentState) (a, SideData)
forall (m :: * -> *) w a.
Monad m =>
(w -> w) -> WriterT w m a -> WriterT w m a
W.censor (\SideData
_ -> SideData
forall a. Monoid a => a
mempty) (WriterT SideData (State IdentState) (a, SideData)
-> WriterT SideData (State IdentState) (a, SideData))
-> WriterT SideData (State IdentState) (a, SideData)
-> WriterT SideData (State IdentState) (a, SideData)
forall a b. (a -> b) -> a -> b
$ WriterT SideData (State IdentState) a
-> WriterT SideData (State IdentState) (a, SideData)
forall (m :: * -> *) w a.
Monad m =>
WriterT w m a -> WriterT w m (a, w)
W.listen (WriterT SideData (State IdentState) a
-> WriterT SideData (State IdentState) (a, SideData))
-> WriterT SideData (State IdentState) a
-> WriterT SideData (State IdentState) (a, SideData)
forall a b. (a -> b) -> a -> b
$ SqlQuery a -> WriterT SideData (State IdentState) a
forall a. SqlQuery a -> WriterT SideData (State IdentState) a
unQ SqlQuery a
baseCase
a
aliasedValue <- a -> SqlQuery a
forall a. ToAlias a => a -> SqlQuery a
toAlias a
ret
let aliasedQuery :: SqlQuery a
aliasedQuery = WriterT SideData (State IdentState) a -> SqlQuery a
forall a. WriterT SideData (State IdentState) a -> SqlQuery a
Q (WriterT SideData (State IdentState) a -> SqlQuery a)
-> WriterT SideData (State IdentState) a -> SqlQuery a
forall a b. (a -> b) -> a -> b
$ State IdentState (a, SideData)
-> WriterT SideData (State IdentState) a
forall w (m :: * -> *) a. m (a, w) -> WriterT w m a
W.WriterT (State IdentState (a, SideData)
-> WriterT SideData (State IdentState) a)
-> State IdentState (a, SideData)
-> WriterT SideData (State IdentState) a
forall a b. (a -> b) -> a -> b
$ (a, SideData) -> State IdentState (a, SideData)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a
aliasedValue, SideData
sideData)
Ident
ident <- DBName -> SqlQuery Ident
newIdentFor (Text -> DBName
DBName Text
"cte")
a
ref <- Ident -> a -> SqlQuery a
forall a. ToAliasReference a => Ident -> a -> SqlQuery a
toAliasReference Ident
ident a
aliasedValue
let refFrom :: From a
refFrom = Ident -> a -> From a
forall a. Ident -> a -> From a
FromCte Ident
ident a
ref
let recursiveQuery :: SqlQuery a
recursiveQuery = From a -> SqlQuery a
recursiveCase From a
refFrom
let clause :: CommonTableExpressionClause
clause = CommonTableExpressionKind
-> Ident
-> (IdentInfo -> (Builder, [PersistValue]))
-> CommonTableExpressionClause
CommonTableExpressionClause CommonTableExpressionKind
RecursiveCommonTableExpression Ident
ident
(\IdentInfo
info -> (Mode -> IdentInfo -> SqlQuery a -> (Builder, [PersistValue])
forall a r backend.
(SqlSelect a r, BackendCompatible SqlBackend backend) =>
Mode
-> (backend, IdentState) -> SqlQuery a -> (Builder, [PersistValue])
toRawSql Mode
SELECT IdentInfo
info SqlQuery a
aliasedQuery)
(Builder, [PersistValue])
-> (Builder, [PersistValue]) -> (Builder, [PersistValue])
forall a. Semigroup a => a -> a -> a
<> (unionKind -> Builder
forall a. RecursiveCteUnion a => a -> Builder
unionKeyword unionKind
unionKind, [PersistValue]
forall a. Monoid a => a
mempty)
(Builder, [PersistValue])
-> (Builder, [PersistValue]) -> (Builder, [PersistValue])
forall a. Semigroup a => a -> a -> a
<> (Mode -> IdentInfo -> SqlQuery a -> (Builder, [PersistValue])
forall a r backend.
(SqlSelect a r, BackendCompatible SqlBackend backend) =>
Mode
-> (backend, IdentState) -> SqlQuery a -> (Builder, [PersistValue])
toRawSql Mode
SELECT IdentInfo
info SqlQuery a
recursiveQuery)
)
WriterT SideData (State IdentState) () -> SqlQuery ()
forall a. WriterT SideData (State IdentState) a -> SqlQuery a
Q (WriterT SideData (State IdentState) () -> SqlQuery ())
-> WriterT SideData (State IdentState) () -> SqlQuery ()
forall a b. (a -> b) -> a -> b
$ SideData -> WriterT SideData (State IdentState) ()
forall (m :: * -> *) w. Monad m => w -> WriterT w m ()
W.tell SideData
forall a. Monoid a => a
mempty{sdCteClause :: [CommonTableExpressionClause]
sdCteClause = [CommonTableExpressionClause
clause]}
From a -> SqlQuery (From a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure From a
refFrom
{-# DEPRECATED ToAliasT "This type alias doesn't do anything. Please delete it. Will be removed in the next release." #-}
type ToAliasT a = a
class ToAlias a where
toAlias :: a -> SqlQuery a
instance ToAlias (SqlExpr (Value a)) where
toAlias :: SqlExpr (Value a) -> SqlQuery (SqlExpr (Value a))
toAlias v :: SqlExpr (Value a)
v@(EAliasedValue Ident
_ SqlExpr (Value a)
_) = SqlExpr (Value a) -> SqlQuery (SqlExpr (Value a))
forall (f :: * -> *) a. Applicative f => a -> f a
pure SqlExpr (Value a)
v
toAlias SqlExpr (Value a)
v = do
Ident
ident <- DBName -> SqlQuery Ident
newIdentFor (Text -> DBName
DBName Text
"v")
SqlExpr (Value a) -> SqlQuery (SqlExpr (Value a))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SqlExpr (Value a) -> SqlQuery (SqlExpr (Value a)))
-> SqlExpr (Value a) -> SqlQuery (SqlExpr (Value a))
forall a b. (a -> b) -> a -> b
$ Ident -> SqlExpr (Value a) -> SqlExpr (Value a)
forall a. Ident -> SqlExpr (Value a) -> SqlExpr (Value a)
EAliasedValue Ident
ident SqlExpr (Value a)
v
instance ToAlias (SqlExpr (Entity a)) where
toAlias :: SqlExpr (Entity a) -> SqlQuery (SqlExpr (Entity a))
toAlias v :: SqlExpr (Entity a)
v@(EAliasedEntityReference Ident
_ Ident
_) = SqlExpr (Entity a) -> SqlQuery (SqlExpr (Entity a))
forall (f :: * -> *) a. Applicative f => a -> f a
pure SqlExpr (Entity a)
v
toAlias v :: SqlExpr (Entity a)
v@(EAliasedEntity Ident
_ Ident
_) = SqlExpr (Entity a) -> SqlQuery (SqlExpr (Entity a))
forall (f :: * -> *) a. Applicative f => a -> f a
pure SqlExpr (Entity a)
v
toAlias (EEntity Ident
tableIdent) = do
Ident
ident <- DBName -> SqlQuery Ident
newIdentFor (Text -> DBName
DBName Text
"v")
SqlExpr (Entity a) -> SqlQuery (SqlExpr (Entity a))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SqlExpr (Entity a) -> SqlQuery (SqlExpr (Entity a)))
-> SqlExpr (Entity a) -> SqlQuery (SqlExpr (Entity a))
forall a b. (a -> b) -> a -> b
$ Ident -> Ident -> SqlExpr (Entity a)
forall val. Ident -> Ident -> SqlExpr (Entity val)
EAliasedEntity Ident
ident Ident
tableIdent
instance ToAlias (SqlExpr (Maybe (Entity a))) where
toAlias :: SqlExpr (Maybe (Entity a)) -> SqlQuery (SqlExpr (Maybe (Entity a)))
toAlias (EMaybe SqlExpr a
e) = SqlExpr a -> SqlExpr (Maybe a)
forall a. SqlExpr a -> SqlExpr (Maybe a)
EMaybe (SqlExpr a -> SqlExpr (Maybe a))
-> SqlQuery (SqlExpr a) -> SqlQuery (SqlExpr (Maybe a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SqlExpr a -> SqlQuery (SqlExpr a)
forall a. ToAlias a => a -> SqlQuery a
toAlias SqlExpr a
e
instance (ToAlias a, ToAlias b) => ToAlias (a,b) where
toAlias :: (a, b) -> SqlQuery (a, b)
toAlias (a
a,b
b) = (,) (a -> b -> (a, b)) -> SqlQuery a -> SqlQuery (b -> (a, b))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> SqlQuery a
forall a. ToAlias a => a -> SqlQuery a
toAlias a
a SqlQuery (b -> (a, b)) -> SqlQuery b -> SqlQuery (a, b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> b -> SqlQuery b
forall a. ToAlias a => a -> SqlQuery a
toAlias b
b
instance ( ToAlias a
, ToAlias b
, ToAlias c
) => ToAlias (a,b,c) where
toAlias :: (a, b, c) -> SqlQuery (a, b, c)
toAlias (a, b, c)
x = ((a, b), c) -> (a, b, c)
forall a b c. ((a, b), c) -> (a, b, c)
to3 (((a, b), c) -> (a, b, c))
-> SqlQuery ((a, b), c) -> SqlQuery (a, b, c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (((a, b), c) -> SqlQuery ((a, b), c)
forall a. ToAlias a => a -> SqlQuery a
toAlias (((a, b), c) -> SqlQuery ((a, b), c))
-> ((a, b), c) -> SqlQuery ((a, b), c)
forall a b. (a -> b) -> a -> b
$ (a, b, c) -> ((a, b), c)
forall a b c. (a, b, c) -> ((a, b), c)
from3 (a, b, c)
x)
instance ( ToAlias a
, ToAlias b
, ToAlias c
, ToAlias d
) => ToAlias (a,b,c,d) where
toAlias :: (a, b, c, d) -> SqlQuery (a, b, c, d)
toAlias (a, b, c, d)
x = ((a, b), (c, d)) -> (a, b, c, d)
forall a b c d. ((a, b), (c, d)) -> (a, b, c, d)
to4 (((a, b), (c, d)) -> (a, b, c, d))
-> SqlQuery ((a, b), (c, d)) -> SqlQuery (a, b, c, d)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (((a, b), (c, d)) -> SqlQuery ((a, b), (c, d))
forall a. ToAlias a => a -> SqlQuery a
toAlias (((a, b), (c, d)) -> SqlQuery ((a, b), (c, d)))
-> ((a, b), (c, d)) -> SqlQuery ((a, b), (c, d))
forall a b. (a -> b) -> a -> b
$ (a, b, c, d) -> ((a, b), (c, d))
forall a b c d. (a, b, c, d) -> ((a, b), (c, d))
from4 (a, b, c, d)
x)
instance ( ToAlias a
, ToAlias b
, ToAlias c
, ToAlias d
, ToAlias e
) => ToAlias (a,b,c,d,e) where
toAlias :: (a, b, c, d, e) -> SqlQuery (a, b, c, d, e)
toAlias (a, b, c, d, e)
x = ((a, b), (c, d), e) -> (a, b, c, d, e)
forall a b c d e. ((a, b), (c, d), e) -> (a, b, c, d, e)
to5 (((a, b), (c, d), e) -> (a, b, c, d, e))
-> SqlQuery ((a, b), (c, d), e) -> SqlQuery (a, b, c, d, e)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (((a, b), (c, d), e) -> SqlQuery ((a, b), (c, d), e)
forall a. ToAlias a => a -> SqlQuery a
toAlias (((a, b), (c, d), e) -> SqlQuery ((a, b), (c, d), e))
-> ((a, b), (c, d), e) -> SqlQuery ((a, b), (c, d), e)
forall a b. (a -> b) -> a -> b
$ (a, b, c, d, e) -> ((a, b), (c, d), e)
forall a b c d e. (a, b, c, d, e) -> ((a, b), (c, d), e)
from5 (a, b, c, d, e)
x)
instance ( ToAlias a
, ToAlias b
, ToAlias c
, ToAlias d
, ToAlias e
, ToAlias f
) => ToAlias (a,b,c,d,e,f) where
toAlias :: (a, b, c, d, e, f) -> SqlQuery (a, b, c, d, e, f)
toAlias (a, b, c, d, e, f)
x = ((a, b), (c, d), (e, f)) -> (a, b, c, d, e, f)
forall a b c d e f. ((a, b), (c, d), (e, f)) -> (a, b, c, d, e, f)
to6 (((a, b), (c, d), (e, f)) -> (a, b, c, d, e, f))
-> SqlQuery ((a, b), (c, d), (e, f)) -> SqlQuery (a, b, c, d, e, f)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (((a, b), (c, d), (e, f)) -> SqlQuery ((a, b), (c, d), (e, f))
forall a. ToAlias a => a -> SqlQuery a
toAlias (((a, b), (c, d), (e, f)) -> SqlQuery ((a, b), (c, d), (e, f)))
-> ((a, b), (c, d), (e, f)) -> SqlQuery ((a, b), (c, d), (e, f))
forall a b. (a -> b) -> a -> b
$ (a, b, c, d, e, f) -> ((a, b), (c, d), (e, f))
forall a b c d e f. (a, b, c, d, e, f) -> ((a, b), (c, d), (e, f))
from6 (a, b, c, d, e, f)
x)
instance ( ToAlias a
, ToAlias b
, ToAlias c
, ToAlias d
, ToAlias e
, ToAlias f
, ToAlias g
) => ToAlias (a,b,c,d,e,f,g) where
toAlias :: (a, b, c, d, e, f, g) -> SqlQuery (a, b, c, d, e, f, g)
toAlias (a, b, c, d, e, f, g)
x = ((a, b), (c, d), (e, f), g) -> (a, b, c, d, e, f, g)
forall a b c d e f g.
((a, b), (c, d), (e, f), g) -> (a, b, c, d, e, f, g)
to7 (((a, b), (c, d), (e, f), g) -> (a, b, c, d, e, f, g))
-> SqlQuery ((a, b), (c, d), (e, f), g)
-> SqlQuery (a, b, c, d, e, f, g)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (((a, b), (c, d), (e, f), g) -> SqlQuery ((a, b), (c, d), (e, f), g)
forall a. ToAlias a => a -> SqlQuery a
toAlias (((a, b), (c, d), (e, f), g)
-> SqlQuery ((a, b), (c, d), (e, f), g))
-> ((a, b), (c, d), (e, f), g)
-> SqlQuery ((a, b), (c, d), (e, f), g)
forall a b. (a -> b) -> a -> b
$ (a, b, c, d, e, f, g) -> ((a, b), (c, d), (e, f), g)
forall a b c d e f g.
(a, b, c, d, e, f, g) -> ((a, b), (c, d), (e, f), g)
from7 (a, b, c, d, e, f, g)
x)
instance ( ToAlias a
, ToAlias b
, ToAlias c
, ToAlias d
, ToAlias e
, ToAlias f
, ToAlias g
, ToAlias h
) => ToAlias (a,b,c,d,e,f,g,h) where
toAlias :: (a, b, c, d, e, f, g, h) -> SqlQuery (a, b, c, d, e, f, g, h)
toAlias (a, b, c, d, e, f, g, h)
x = ((a, b), (c, d), (e, f), (g, h)) -> (a, b, c, d, e, f, g, h)
forall a b c d e f g h.
((a, b), (c, d), (e, f), (g, h)) -> (a, b, c, d, e, f, g, h)
to8 (((a, b), (c, d), (e, f), (g, h)) -> (a, b, c, d, e, f, g, h))
-> SqlQuery ((a, b), (c, d), (e, f), (g, h))
-> SqlQuery (a, b, c, d, e, f, g, h)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (((a, b), (c, d), (e, f), (g, h))
-> SqlQuery ((a, b), (c, d), (e, f), (g, h))
forall a. ToAlias a => a -> SqlQuery a
toAlias (((a, b), (c, d), (e, f), (g, h))
-> SqlQuery ((a, b), (c, d), (e, f), (g, h)))
-> ((a, b), (c, d), (e, f), (g, h))
-> SqlQuery ((a, b), (c, d), (e, f), (g, h))
forall a b. (a -> b) -> a -> b
$ (a, b, c, d, e, f, g, h) -> ((a, b), (c, d), (e, f), (g, h))
forall a b c d e f g h.
(a, b, c, d, e, f, g, h) -> ((a, b), (c, d), (e, f), (g, h))
from8 (a, b, c, d, e, f, g, h)
x)
{-# DEPRECATED ToAliasReferenceT "This type alias doesn't do anything. Please delete it. Will be removed in the next release." #-}
type ToAliasReferenceT a = a
class ToAliasReference a where
toAliasReference :: Ident -> a -> SqlQuery a
instance ToAliasReference (SqlExpr (Value a)) where
toAliasReference :: Ident -> SqlExpr (Value a) -> SqlQuery (SqlExpr (Value a))
toAliasReference Ident
aliasSource (EAliasedValue Ident
aliasIdent SqlExpr (Value a)
_) = SqlExpr (Value a) -> SqlQuery (SqlExpr (Value a))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SqlExpr (Value a) -> SqlQuery (SqlExpr (Value a)))
-> SqlExpr (Value a) -> SqlQuery (SqlExpr (Value a))
forall a b. (a -> b) -> a -> b
$ Ident -> (IdentInfo -> Ident) -> SqlExpr (Value a)
forall a. Ident -> (IdentInfo -> Ident) -> SqlExpr (Value a)
EValueReference Ident
aliasSource (\IdentInfo
_ -> Ident
aliasIdent)
toAliasReference Ident
_ v :: SqlExpr (Value a)
v@(ERaw NeedParens
_ IdentInfo -> (Builder, [PersistValue])
_) = SqlExpr (Value a) -> SqlQuery (SqlExpr (Value a))
forall a. ToAlias a => a -> SqlQuery a
toAlias SqlExpr (Value a)
v
toAliasReference Ident
_ v :: SqlExpr (Value a)
v@(ECompositeKey IdentInfo -> [Builder]
_) = SqlExpr (Value a) -> SqlQuery (SqlExpr (Value a))
forall a. ToAlias a => a -> SqlQuery a
toAlias SqlExpr (Value a)
v
toAliasReference Ident
s (EValueReference Ident
_ IdentInfo -> Ident
b) = SqlExpr (Value a) -> SqlQuery (SqlExpr (Value a))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SqlExpr (Value a) -> SqlQuery (SqlExpr (Value a)))
-> SqlExpr (Value a) -> SqlQuery (SqlExpr (Value a))
forall a b. (a -> b) -> a -> b
$ Ident -> (IdentInfo -> Ident) -> SqlExpr (Value a)
forall a. Ident -> (IdentInfo -> Ident) -> SqlExpr (Value a)
EValueReference Ident
s IdentInfo -> Ident
b
instance ToAliasReference (SqlExpr (Entity a)) where
toAliasReference :: Ident -> SqlExpr (Entity a) -> SqlQuery (SqlExpr (Entity a))
toAliasReference Ident
aliasSource (EAliasedEntity Ident
ident Ident
_) = SqlExpr (Entity a) -> SqlQuery (SqlExpr (Entity a))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SqlExpr (Entity a) -> SqlQuery (SqlExpr (Entity a)))
-> SqlExpr (Entity a) -> SqlQuery (SqlExpr (Entity a))
forall a b. (a -> b) -> a -> b
$ Ident -> Ident -> SqlExpr (Entity a)
forall val. Ident -> Ident -> SqlExpr (Entity val)
EAliasedEntityReference Ident
aliasSource Ident
ident
toAliasReference Ident
_ e :: SqlExpr (Entity a)
e@(EEntity Ident
_) = SqlExpr (Entity a) -> SqlQuery (SqlExpr (Entity a))
forall a. ToAlias a => a -> SqlQuery a
toAlias SqlExpr (Entity a)
e
toAliasReference Ident
s (EAliasedEntityReference Ident
_ Ident
b) = SqlExpr (Entity a) -> SqlQuery (SqlExpr (Entity a))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SqlExpr (Entity a) -> SqlQuery (SqlExpr (Entity a)))
-> SqlExpr (Entity a) -> SqlQuery (SqlExpr (Entity a))
forall a b. (a -> b) -> a -> b
$ Ident -> Ident -> SqlExpr (Entity a)
forall val. Ident -> Ident -> SqlExpr (Entity val)
EAliasedEntityReference Ident
s Ident
b
instance ToAliasReference (SqlExpr (Maybe (Entity a))) where
toAliasReference :: Ident
-> SqlExpr (Maybe (Entity a))
-> SqlQuery (SqlExpr (Maybe (Entity a)))
toAliasReference Ident
s (EMaybe SqlExpr a
e) = SqlExpr a -> SqlExpr (Maybe a)
forall a. SqlExpr a -> SqlExpr (Maybe a)
EMaybe (SqlExpr a -> SqlExpr (Maybe a))
-> SqlQuery (SqlExpr a) -> SqlQuery (SqlExpr (Maybe a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ident -> SqlExpr a -> SqlQuery (SqlExpr a)
forall a. ToAliasReference a => Ident -> a -> SqlQuery a
toAliasReference Ident
s SqlExpr a
e
instance (ToAliasReference a, ToAliasReference b) => ToAliasReference (a, b) where
toAliasReference :: Ident -> (a, b) -> SqlQuery (a, b)
toAliasReference Ident
ident (a
a,b
b) = (,) (a -> b -> (a, b)) -> SqlQuery a -> SqlQuery (b -> (a, b))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Ident -> a -> SqlQuery a
forall a. ToAliasReference a => Ident -> a -> SqlQuery a
toAliasReference Ident
ident a
a) SqlQuery (b -> (a, b)) -> SqlQuery b -> SqlQuery (a, b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Ident -> b -> SqlQuery b
forall a. ToAliasReference a => Ident -> a -> SqlQuery a
toAliasReference Ident
ident b
b)
instance ( ToAliasReference a
, ToAliasReference b
, ToAliasReference c
) => ToAliasReference (a,b,c) where
toAliasReference :: Ident -> (a, b, c) -> SqlQuery (a, b, c)
toAliasReference Ident
ident (a, b, c)
x = (((a, b), c) -> (a, b, c))
-> SqlQuery ((a, b), c) -> SqlQuery (a, b, c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a, b), c) -> (a, b, c)
forall a b c. ((a, b), c) -> (a, b, c)
to3 (SqlQuery ((a, b), c) -> SqlQuery (a, b, c))
-> SqlQuery ((a, b), c) -> SqlQuery (a, b, c)
forall a b. (a -> b) -> a -> b
$ Ident -> ((a, b), c) -> SqlQuery ((a, b), c)
forall a. ToAliasReference a => Ident -> a -> SqlQuery a
toAliasReference Ident
ident (((a, b), c) -> SqlQuery ((a, b), c))
-> ((a, b), c) -> SqlQuery ((a, b), c)
forall a b. (a -> b) -> a -> b
$ (a, b, c) -> ((a, b), c)
forall a b c. (a, b, c) -> ((a, b), c)
from3 (a, b, c)
x
instance ( ToAliasReference a
, ToAliasReference b
, ToAliasReference c
, ToAliasReference d
) => ToAliasReference (a,b,c,d) where
toAliasReference :: Ident -> (a, b, c, d) -> SqlQuery (a, b, c, d)
toAliasReference Ident
ident (a, b, c, d)
x = (((a, b), (c, d)) -> (a, b, c, d))
-> SqlQuery ((a, b), (c, d)) -> SqlQuery (a, b, c, d)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a, b), (c, d)) -> (a, b, c, d)
forall a b c d. ((a, b), (c, d)) -> (a, b, c, d)
to4 (SqlQuery ((a, b), (c, d)) -> SqlQuery (a, b, c, d))
-> SqlQuery ((a, b), (c, d)) -> SqlQuery (a, b, c, d)
forall a b. (a -> b) -> a -> b
$ Ident -> ((a, b), (c, d)) -> SqlQuery ((a, b), (c, d))
forall a. ToAliasReference a => Ident -> a -> SqlQuery a
toAliasReference Ident
ident (((a, b), (c, d)) -> SqlQuery ((a, b), (c, d)))
-> ((a, b), (c, d)) -> SqlQuery ((a, b), (c, d))
forall a b. (a -> b) -> a -> b
$ (a, b, c, d) -> ((a, b), (c, d))
forall a b c d. (a, b, c, d) -> ((a, b), (c, d))
from4 (a, b, c, d)
x
instance ( ToAliasReference a
, ToAliasReference b
, ToAliasReference c
, ToAliasReference d
, ToAliasReference e
) => ToAliasReference (a,b,c,d,e) where
toAliasReference :: Ident -> (a, b, c, d, e) -> SqlQuery (a, b, c, d, e)
toAliasReference Ident
ident (a, b, c, d, e)
x = (((a, b), (c, d), e) -> (a, b, c, d, e))
-> SqlQuery ((a, b), (c, d), e) -> SqlQuery (a, b, c, d, e)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a, b), (c, d), e) -> (a, b, c, d, e)
forall a b c d e. ((a, b), (c, d), e) -> (a, b, c, d, e)
to5 (SqlQuery ((a, b), (c, d), e) -> SqlQuery (a, b, c, d, e))
-> SqlQuery ((a, b), (c, d), e) -> SqlQuery (a, b, c, d, e)
forall a b. (a -> b) -> a -> b
$ Ident -> ((a, b), (c, d), e) -> SqlQuery ((a, b), (c, d), e)
forall a. ToAliasReference a => Ident -> a -> SqlQuery a
toAliasReference Ident
ident (((a, b), (c, d), e) -> SqlQuery ((a, b), (c, d), e))
-> ((a, b), (c, d), e) -> SqlQuery ((a, b), (c, d), e)
forall a b. (a -> b) -> a -> b
$ (a, b, c, d, e) -> ((a, b), (c, d), e)
forall a b c d e. (a, b, c, d, e) -> ((a, b), (c, d), e)
from5 (a, b, c, d, e)
x
instance ( ToAliasReference a
, ToAliasReference b
, ToAliasReference c
, ToAliasReference d
, ToAliasReference e
, ToAliasReference f
) => ToAliasReference (a,b,c,d,e,f) where
toAliasReference :: Ident -> (a, b, c, d, e, f) -> SqlQuery (a, b, c, d, e, f)
toAliasReference Ident
ident (a, b, c, d, e, f)
x = ((a, b), (c, d), (e, f)) -> (a, b, c, d, e, f)
forall a b c d e f. ((a, b), (c, d), (e, f)) -> (a, b, c, d, e, f)
to6 (((a, b), (c, d), (e, f)) -> (a, b, c, d, e, f))
-> SqlQuery ((a, b), (c, d), (e, f)) -> SqlQuery (a, b, c, d, e, f)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Ident
-> ((a, b), (c, d), (e, f)) -> SqlQuery ((a, b), (c, d), (e, f))
forall a. ToAliasReference a => Ident -> a -> SqlQuery a
toAliasReference Ident
ident (((a, b), (c, d), (e, f)) -> SqlQuery ((a, b), (c, d), (e, f)))
-> ((a, b), (c, d), (e, f)) -> SqlQuery ((a, b), (c, d), (e, f))
forall a b. (a -> b) -> a -> b
$ (a, b, c, d, e, f) -> ((a, b), (c, d), (e, f))
forall a b c d e f. (a, b, c, d, e, f) -> ((a, b), (c, d), (e, f))
from6 (a, b, c, d, e, f)
x)
instance ( ToAliasReference a
, ToAliasReference b
, ToAliasReference c
, ToAliasReference d
, ToAliasReference e
, ToAliasReference f
, ToAliasReference g
) => ToAliasReference (a,b,c,d,e,f,g) where
toAliasReference :: Ident -> (a, b, c, d, e, f, g) -> SqlQuery (a, b, c, d, e, f, g)
toAliasReference Ident
ident (a, b, c, d, e, f, g)
x = ((a, b), (c, d), (e, f), g) -> (a, b, c, d, e, f, g)
forall a b c d e f g.
((a, b), (c, d), (e, f), g) -> (a, b, c, d, e, f, g)
to7 (((a, b), (c, d), (e, f), g) -> (a, b, c, d, e, f, g))
-> SqlQuery ((a, b), (c, d), (e, f), g)
-> SqlQuery (a, b, c, d, e, f, g)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Ident
-> ((a, b), (c, d), (e, f), g)
-> SqlQuery ((a, b), (c, d), (e, f), g)
forall a. ToAliasReference a => Ident -> a -> SqlQuery a
toAliasReference Ident
ident (((a, b), (c, d), (e, f), g)
-> SqlQuery ((a, b), (c, d), (e, f), g))
-> ((a, b), (c, d), (e, f), g)
-> SqlQuery ((a, b), (c, d), (e, f), g)
forall a b. (a -> b) -> a -> b
$ (a, b, c, d, e, f, g) -> ((a, b), (c, d), (e, f), g)
forall a b c d e f g.
(a, b, c, d, e, f, g) -> ((a, b), (c, d), (e, f), g)
from7 (a, b, c, d, e, f, g)
x)
instance ( ToAliasReference a
, ToAliasReference b
, ToAliasReference c
, ToAliasReference d
, ToAliasReference e
, ToAliasReference f
, ToAliasReference g
, ToAliasReference h
) => ToAliasReference (a,b,c,d,e,f,g,h) where
toAliasReference :: Ident
-> (a, b, c, d, e, f, g, h) -> SqlQuery (a, b, c, d, e, f, g, h)
toAliasReference Ident
ident (a, b, c, d, e, f, g, h)
x = ((a, b), (c, d), (e, f), (g, h)) -> (a, b, c, d, e, f, g, h)
forall a b c d e f g h.
((a, b), (c, d), (e, f), (g, h)) -> (a, b, c, d, e, f, g, h)
to8 (((a, b), (c, d), (e, f), (g, h)) -> (a, b, c, d, e, f, g, h))
-> SqlQuery ((a, b), (c, d), (e, f), (g, h))
-> SqlQuery (a, b, c, d, e, f, g, h)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Ident
-> ((a, b), (c, d), (e, f), (g, h))
-> SqlQuery ((a, b), (c, d), (e, f), (g, h))
forall a. ToAliasReference a => Ident -> a -> SqlQuery a
toAliasReference Ident
ident (((a, b), (c, d), (e, f), (g, h))
-> SqlQuery ((a, b), (c, d), (e, f), (g, h)))
-> ((a, b), (c, d), (e, f), (g, h))
-> SqlQuery ((a, b), (c, d), (e, f), (g, h))
forall a b. (a -> b) -> a -> b
$ (a, b, c, d, e, f, g, h) -> ((a, b), (c, d), (e, f), (g, h))
forall a b c d e f g h.
(a, b, c, d, e, f, g, h) -> ((a, b), (c, d), (e, f), (g, h))
from8 (a, b, c, d, e, f, g, h)
x)
class RecursiveCteUnion a where
unionKeyword :: a -> TLB.Builder
instance RecursiveCteUnion (a -> b -> Union a b) where
unionKeyword :: (a -> b -> Union a b) -> Builder
unionKeyword a -> b -> Union a b
_ = Builder
"\nUNION\n"
instance RecursiveCteUnion (a -> b -> UnionAll a b) where
unionKeyword :: (a -> b -> UnionAll a b) -> Builder
unionKeyword a -> b -> UnionAll a b
_ = Builder
"\nUNION ALL\n"