Copyright	2019 Kei Hibino
License	BSD3
Maintainer	ex8k.hibino@gmail.com
Stability	experimental
Portability	unknown
Safe Haskell	None
Language	Haskell2010

Database.Custom.IBMDB2

Description

This module provides custom APIs with appropriate configuration for IBMDB2.

Synopsis

derivedUniqueRelation :: TableDerivable r => Key Unique r k -> Record c k -> UniqueRelation () c r
primaryUpdate :: HasConstraintKey Primary r p => Table r -> KeyUpdate p r
updateByConstraintKey :: Table r -> Key c r p -> KeyUpdate p r
updateValuesWithKey :: ToSql q r => Pi r p -> r -> [q]
primary :: HasConstraintKey Primary a p => Relation () a -> Relation p a
primarySelect :: HasConstraintKey Primary a p => Relation () a -> Relation p a
primary' :: PersistableWidth p => Key Primary a p -> Relation () a -> Relation p a
unique :: PersistableWidth p => Key Unique a p -> Relation () a -> Relation p a
uniqueSelect :: PersistableWidth p => Key Unique a p -> Relation () a -> Relation p a
specifiedKey :: PersistableWidth p => Pi a p -> Relation () a -> Relation p a
updateNumber :: (PersistableWidth s, Integral i, LiteralSQL i) => i -> Sequence s i -> Update ()
updateNumber' :: (PersistableWidth s, Integral i, LiteralSQL i) => Config -> i -> Sequence s i -> Update ()
($$) :: Binding r s i => (i -> r) -> Number r i -> r
($$!) :: (i -> r) -> Number r i -> r
extractNumber :: Number r i -> i
unsafeSpecifyNumber :: Binding r s i => i -> Number r i
fromRelation :: Binding r s i => Relation () r -> Sequence s i
primaryBinding :: (TableDerivable r, SequenceDerivable s i, HasConstraintKey Primary r i) => SeqBinding r s i
unsafeSpecifyBinding :: (TableDerivable r, SequenceDerivable s i) => Pi r i -> SeqBinding r s i
seqRelation :: TableDerivable s => Sequence s i -> Relation () s
unsafeSpecifySequence :: TableDerivable s => (s -> i) -> Pi s i -> Sequence s i
data Sequence s i
class TableDerivable s => SequenceDerivable s i | s -> i where
- derivedSequence :: Sequence s i
data SeqBinding r s i
class (TableDerivable r, SequenceDerivable s i) => Binding r s i | r -> s where
- binding :: SeqBinding r s i
data Number r i
derivedDelete :: TableDerivable r => (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
derivedDelete' :: TableDerivable r => Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
delete' :: TableDerivable r => Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
typedDelete :: Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
typedDelete' :: Config -> Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
deleteSQL :: Config -> Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> String
derivedInsertQuery :: TableDerivable r => Pi r r' -> Relation p r' -> InsertQuery p
insertQuery' :: TableDerivable r => Config -> Pi r r' -> Relation p r' -> InsertQuery p
typedInsertQuery :: Table r -> Pi r r' -> Relation p r' -> InsertQuery p
typedInsertQuery' :: Config -> Table r -> Pi r r' -> Relation p r' -> InsertQuery p
insertQuerySQL :: Config -> Table r -> Pi r r' -> Relation p r' -> String
insertValueList :: (TableDerivable r, LiteralSQL r') => Pi r r' -> [r'] -> [Insert ()]
insertValueList' :: (TableDerivable r, LiteralSQL r') => Config -> Pi r r' -> [r'] -> [Insert ()]
derivedInsertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p
derivedInsertValue' :: TableDerivable r => Config -> Register r (PlaceHolders p) -> Insert p
insertValue' :: TableDerivable r => Config -> Register r (PlaceHolders p) -> Insert p
typedInsertValue :: Table r -> InsertTarget p r -> Insert p
typedInsertValue' :: Config -> Table r -> InsertTarget p r -> Insert p
derivedInsert :: (PersistableWidth r, TableDerivable r) => Pi r r' -> Insert r'
insert :: (PersistableWidth r, TableDerivable r) => Pi r r' -> Insert r'
typedInsert :: PersistableWidth r => Table r -> Pi r r' -> Insert r'
typedInsert' :: PersistableWidth r => Config -> Table r -> Pi r r' -> Insert r'
unsafeTypedInsert' :: String -> String -> Int -> Insert a
chunkSizeOfInsert :: Insert a -> Int
untypeChunkInsert :: Insert a -> String
derivedUpdateAllColumn :: (PersistableWidth r, TableDerivable r) => (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)
updateAllColumnNoPH :: (PersistableWidth r, TableDerivable r) => (Record Flat r -> Restrict ()) -> Update r
updateAllColumn :: (PersistableWidth r, TableDerivable r) => (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)
derivedUpdateAllColumn' :: (PersistableWidth r, TableDerivable r) => Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)
updateAllColumn' :: (PersistableWidth r, TableDerivable r) => Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)
typedUpdateAllColumn :: PersistableWidth r => Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)
derivedUpdate :: TableDerivable r => (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
derivedUpdate' :: TableDerivable r => Config -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
update' :: TableDerivable r => Config -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
typedUpdate :: Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
typedUpdate' :: Config -> Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
updateSQL :: Config -> Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> String
unsafeTypedUpdate :: String -> Update p
derivedKeyUpdate :: TableDerivable r => Pi r p -> KeyUpdate p r
keyUpdate :: TableDerivable r => Pi r p -> KeyUpdate p r
typedKeyUpdateTable :: TableDerivable r => Relation () r -> Pi r p -> KeyUpdate p r
typedKeyUpdate :: Table a -> Pi a p -> KeyUpdate p a
relationalQuery' :: Relation p r -> QuerySuffix -> Query p r
relationalQuery_ :: Config -> Relation p r -> QuerySuffix -> Query p r
relationalQuerySQL :: Config -> Relation p r -> QuerySuffix -> String
unsafeTypedQuery :: String -> Query p a
newtype Query p a = Query {
- untypeQuery :: String
}
data KeyUpdate p a = KeyUpdate {
- updateKey :: Pi a p
- untypeKeyUpdate :: String
}
newtype Update p = Update {
- untypeUpdate :: String
}
data Insert a = Insert {
- untypeInsert :: String
- chunkedInsert :: Maybe (String, Int)
}
newtype InsertQuery p = InsertQuery {
- untypeInsertQuery :: String
}
newtype Delete p = Delete {
- untypeDelete :: String
}
class UntypeableNoFetch (s :: Type -> Type) where
- untypeNoFetch :: s p -> String
sqlChunksFromRecordList :: LiteralSQL r' => Config -> Table r -> Pi r r' -> [r'] -> [StringSQL]
sqlFromInsertTarget :: Config -> Table r -> InsertTarget p r -> StringSQL
sqlChunkFromInsertTarget :: Config -> Table r -> InsertTarget p r -> (StringSQL, Int)
piRegister :: PersistableWidth r => Pi r r' -> Register r (PlaceHolders r')
insertTarget' :: Register r (PlaceHolders p) -> InsertTarget p r
insertTarget :: Register r () -> InsertTarget () r
sqlFromUpdateTarget :: Config -> Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> StringSQL
updateTargetAllColumn' :: PersistableWidth r => (Record Flat r -> Restrict (PlaceHolders p)) -> Record Flat r -> Assign r (PlaceHolders (r, p))
updateTargetAllColumn :: PersistableWidth r => (Record Flat r -> Restrict ()) -> Record Flat r -> Assign r (PlaceHolders r)
liftTargetAllColumn' :: PersistableWidth r => (Record Flat r -> Restrict (PlaceHolders p)) -> Record Flat r -> Assign r (PlaceHolders (r, p))
liftTargetAllColumn :: PersistableWidth r => (Record Flat r -> Restrict (PlaceHolders ())) -> Record Flat r -> Assign r (PlaceHolders r)
updateTarget' :: (Record Flat r -> Assign r (PlaceHolders p)) -> UpdateTarget p r
updateTarget :: (Record Flat r -> Assign r ()) -> UpdateTarget () r
sqlWhereFromRestriction :: Config -> Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> StringSQL
restriction' :: (Record Flat r -> Restrict (PlaceHolders p)) -> Restriction p r
restriction :: (Record Flat r -> Restrict ()) -> Restriction () r
type Restriction p r = Record Flat r -> Restrict (PlaceHolders p)
type UpdateTarget p r = Record Flat r -> Assign r (PlaceHolders p)
data InsertTarget p r
intersectAll' :: Relation p a -> Relation q a -> Relation (p, q) a
intersect' :: Relation p a -> Relation q a -> Relation (p, q) a
exceptAll' :: Relation p a -> Relation q a -> Relation (p, q) a
except' :: Relation p a -> Relation q a -> Relation (p, q) a
unionAll' :: Relation p a -> Relation q a -> Relation (p, q) a
union' :: Relation p a -> Relation q a -> Relation (p, q) a
intersectAll :: Relation () a -> Relation () a -> Relation () a
intersect :: Relation () a -> Relation () a -> Relation () a
exceptAll :: Relation () a -> Relation () a -> Relation () a
except :: Relation () a -> Relation () a -> Relation () a
unionAll :: Relation () a -> Relation () a -> Relation () a
union :: Relation () a -> Relation () a -> Relation () a
on' :: ([JoinRestriction a b] -> Relation pc (a, b)) -> [JoinRestriction a b] -> Relation pc (a, b)
full :: Relation () a -> Relation () b -> [JoinRestriction (Maybe a) (Maybe b)] -> Relation () (Maybe a, Maybe b)
right :: Relation () a -> Relation () b -> [JoinRestriction (Maybe a) b] -> Relation () (Maybe a, b)
left :: Relation () a -> Relation () b -> [JoinRestriction a (Maybe b)] -> Relation () (a, Maybe b)
inner :: Relation () a -> Relation () b -> [JoinRestriction a b] -> Relation () (a, b)
full' :: Relation pa a -> Relation pb b -> [JoinRestriction (Maybe a) (Maybe b)] -> Relation (pa, pb) (Maybe a, Maybe b)
right' :: Relation pa a -> Relation pb b -> [JoinRestriction (Maybe a) b] -> Relation (pa, pb) (Maybe a, b)
left' :: Relation pa a -> Relation pb b -> [JoinRestriction a (Maybe b)] -> Relation (pa, pb) (a, Maybe b)
inner' :: Relation pa a -> Relation pb b -> [JoinRestriction a b] -> Relation (pa, pb) (a, b)
type JoinRestriction a b = Record Flat a -> Record Flat b -> Predicate Flat
queryScalar :: (MonadQualify ConfigureQuery m, ScalarDegree r) => UniqueRelation () c r -> m (Record c (Maybe r))
queryScalar' :: (MonadQualify ConfigureQuery m, ScalarDegree r) => UniqueRelation p c r -> m (PlaceHolders p, Record c (Maybe r))
aggregatedUnique :: Relation ph r -> Pi r a -> (Record Flat a -> Record Aggregated b) -> UniqueRelation ph Flat b
uniqueRelation' :: QueryUnique (PlaceHolders p, Record c r) -> UniqueRelation p c r
uniqueQueryMaybe' :: UniqueRelation p c r -> QueryUnique (PlaceHolders p, Record c (Maybe r))
uniqueQuery' :: UniqueRelation p c r -> QueryUnique (PlaceHolders p, Record c r)
unUnique :: UniqueRelation p c r -> Relation p r
unsafeUnique :: Relation p r -> UniqueRelation p c r
aggregateRelation :: QueryAggregate (Record Aggregated r) -> Relation () r
aggregateRelation' :: AggregatedQuery p r -> Relation p r
relation :: QuerySimple (Record Flat r) -> Relation () r
relation' :: SimpleQuery p r -> Relation p r
queryList :: MonadQualify ConfigureQuery m => Relation () r -> m (RecordList (Record c) r)
queryList' :: MonadQualify ConfigureQuery m => Relation p r -> m (PlaceHolders p, RecordList (Record c) r)
queryMaybe :: (MonadQualify ConfigureQuery m, MonadQuery m) => Relation () r -> m (Record Flat (Maybe r))
query :: (MonadQualify ConfigureQuery m, MonadQuery m) => Relation () r -> m (Record Flat r)
tableOf :: TableDerivable r => Relation () r -> Table r
derivedRelation :: TableDerivable r => Relation () r
table :: Table r -> Relation () r
data UniqueRelation p c r
over :: SqlContext c => Record OverWindow a -> Window c () -> Record c a
type QueryAggregate = Orderings Aggregated (Restrictings Aggregated (AggregatingSetT QueryCore))
type AggregatedQuery p r = OrderedQuery Aggregated (Restrictings Aggregated (AggregatingSetT QueryCore)) p r
type Window c = Orderings c (PartitioningSet c)
groupingSets :: AggregatingSetList a -> AggregateKey a
cube :: AggregatingPowerSet a -> AggregateKey a
rollup :: AggregatingPowerSet a -> AggregateKey a
bkey :: Record Flat r -> AggregatingPowerSet (Record Aggregated (Maybe r))
set :: AggregatingSet a -> AggregatingSetList a
key' :: AggregateKey a -> AggregatingSet a
key :: Record Flat r -> AggregatingSet (Record Aggregated (Maybe r))
type Assign r = Assignings r Restrict
type Register r = Assignings r ConfigureQuery
(<-#) :: forall (m :: Type -> Type) r v. Monad m => AssignTarget r v -> Record Flat v -> Assignings r m ()
assignTo :: forall (m :: Type -> Type) v r. Monad m => Record Flat v -> AssignTarget r v -> Assignings r m ()
type QuerySimple = Orderings Flat QueryCore
type SimpleQuery p r = OrderedQuery Flat QueryCore p r
data QueryUnique a
extractCore :: QueryCore a -> ConfigureQuery (((a, [Predicate Flat]), JoinProduct), Duplication)
type QueryCore = Restrictings Flat (QueryJoin ConfigureQuery)
type OrderedQuery c (m :: Type -> Type) p r = Orderings c m (PlaceHolders p, Record c r)
desc :: forall (m :: Type -> Type) c t. Monad m => Record c t -> Orderings c m ()
asc :: forall (m :: Type -> Type) c t. Monad m => Record c t -> Orderings c m ()
orderBy :: forall (m :: Type -> Type) c t. Monad m => Record c t -> Order -> Orderings c m ()
orderBy' :: forall (m :: Type -> Type) c t. Monad m => Record c t -> Order -> Nulls -> Orderings c m ()
data Orderings c (m :: Type -> Type) a
type Restrict = Restrictings Flat ConfigureQuery
having :: MonadRestrict Aggregated m => Predicate Aggregated -> m ()
wheres :: MonadRestrict Flat m => Predicate Flat -> m ()
on :: MonadQuery m => Predicate Flat -> m ()
distinct :: MonadQuery m => m ()
all' :: MonadQuery m => m ()
class (Functor m, Monad m) => MonadRestrict c (m :: Type -> Type) where
- restrict :: Predicate c -> m ()
class (Functor m, Monad m, MonadQualify ConfigureQuery m) => MonadQuery (m :: Type -> Type) where
- query' :: Relation p r -> m (PlaceHolders p, Record Flat r)
- queryMaybe' :: Relation p r -> m (PlaceHolders p, Record Flat (Maybe r))
class (Functor q, Monad q, Functor m, Monad m) => MonadQualify (q :: Type -> Type) (m :: Type -> Type)
class MonadQuery m => MonadAggregate (m :: Type -> Type) where
- groupBy :: Record Flat r -> m (Record Aggregated r)
- groupBy' :: AggregateKey (Record Aggregated r) -> m (Record Aggregated r)
class Monad m => MonadPartition c (m :: Type -> Type) where
- partitionBy :: Record c r -> m ()
(??) :: PersistableWidth a => Record c (Maybe a) -> Pi a (Maybe b) -> Record c (Maybe b)
(?) :: PersistableWidth a => Record c (Maybe a) -> Pi a b -> Record c (Maybe b)
(!??) :: (PersistableWidth a, ProjectableFlattenMaybe (Maybe b) c) => Record cont (Maybe a) -> Pi a b -> Record cont c
flattenPiMaybe :: (PersistableWidth a, ProjectableFlattenMaybe (Maybe b) c) => Record cont (Maybe a) -> Pi a b -> Record cont c
(?!?) :: PersistableWidth a => Record c (Maybe a) -> Pi a (Maybe b) -> Record c (Maybe b)
(?!) :: PersistableWidth a => Record c (Maybe a) -> Pi a b -> Record c (Maybe b)
(!) :: PersistableWidth a => Record c a -> Pi a b -> Record c b
some' :: (AggregatedContext ac, SqlContext ac) => Predicate Flat -> Record ac (Maybe Bool)
any' :: (AggregatedContext ac, SqlContext ac) => Predicate Flat -> Record ac (Maybe Bool)
every :: (AggregatedContext ac, SqlContext ac) => Predicate Flat -> Record ac (Maybe Bool)
min' :: (Ord a, AggregatedContext ac, SqlContext ac) => Record Flat a -> Record ac (Maybe a)
minMaybe :: (Ord a, AggregatedContext ac, SqlContext ac) => Record Flat (Maybe a) -> Record ac (Maybe a)
max' :: (Ord a, AggregatedContext ac, SqlContext ac) => Record Flat a -> Record ac (Maybe a)
maxMaybe :: (Ord a, AggregatedContext ac, SqlContext ac) => Record Flat (Maybe a) -> Record ac (Maybe a)
avg :: (Num a, Fractional b, AggregatedContext ac, SqlContext ac) => Record Flat a -> Record ac (Maybe b)
avgMaybe :: (Num a, Fractional b, AggregatedContext ac, SqlContext ac) => Record Flat (Maybe a) -> Record ac (Maybe b)
sum' :: (Num a, AggregatedContext ac, SqlContext ac) => Record Flat a -> Record ac (Maybe a)
sumMaybe :: (Num a, AggregatedContext ac, SqlContext ac) => Record Flat (Maybe a) -> Record ac (Maybe a)
count :: (Integral b, AggregatedContext ac, SqlContext ac) => Record Flat a -> Record ac b
unsafeAggregateOp :: (AggregatedContext ac, SqlContext ac) => Keyword -> Record Flat a -> Record ac b
(><) :: ProductIsoApplicative p => p a -> p b -> p (a, b)
projectZip :: ProductIsoApplicative p => p a -> p b -> p (a, b)
placeholder :: (PersistableWidth t, SqlContext c, Monad m) => (Record c t -> m a) -> m (PlaceHolders t, a)
placeholder' :: (PersistableWidth t, SqlContext c) => (Record c t -> a) -> (PlaceHolders t, a)
pwPlaceholder :: SqlContext c => PersistableRecordWidth a -> (Record c a -> b) -> (PlaceHolders a, b)
unitPH :: PlaceHolders ()
unitPlaceHolder :: PlaceHolders ()
unsafePlaceHolders :: PlaceHolders p
unsafeAddPlaceHolders :: Functor f => f a -> f (PlaceHolders p, a)
cumeDist :: Record OverWindow Double
percentRank :: Record OverWindow Double
rowNumber :: Integral a => Record OverWindow a
denseRank :: Integral a => Record OverWindow a
rank :: Integral a => Record OverWindow a
fromMaybe :: (OperatorContext c, HasColumnConstraint NotNull r) => Record c r -> Record c (Maybe r) -> Record c r
isJust :: (OperatorContext c, HasColumnConstraint NotNull r) => Record c (Maybe r) -> Predicate c
isNothing :: (OperatorContext c, HasColumnConstraint NotNull r) => Record c (Maybe r) -> Predicate c
in' :: OperatorContext c => Record c t -> RecordList (Record c) t -> Record c (Maybe Bool)
caseMaybe :: (OperatorContext c, PersistableWidth b) => Record c a -> [(Record c a, Record c (Maybe b))] -> Record c (Maybe b)
casesOrElse' :: OperatorContext c => (Record c a, [(Record c a, Record c b)]) -> Record c b -> Record c b
case' :: OperatorContext c => Record c a -> [(Record c a, Record c b)] -> Record c b -> Record c b
caseSearchMaybe :: (OperatorContext c, PersistableWidth a) => [(Predicate c, Record c (Maybe a))] -> Record c (Maybe a)
casesOrElse :: OperatorContext c => [(Predicate c, Record c a)] -> Record c a -> Record c a
caseSearch :: OperatorContext c => [(Predicate c, Record c a)] -> Record c a -> Record c a
showNumMaybe :: (SqlContext c, Num a, IsString b) => Record c (Maybe a) -> Record c (Maybe b)
fromIntegralMaybe :: (SqlContext c, Integral a, Num b) => Record c (Maybe a) -> Record c (Maybe b)
negateMaybe :: (OperatorContext c, Num a) => Record c (Maybe a) -> Record c (Maybe a)
(?*?) :: (OperatorContext c, Num a) => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a)
(?/?) :: (OperatorContext c, Num a) => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a)
(?-?) :: (OperatorContext c, Num a) => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a)
(?+?) :: (OperatorContext c, Num a) => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a)
showNum :: (SqlContext c, Num a, IsString b) => Record c a -> Record c b
fromIntegral' :: (SqlContext c, Integral a, Num b) => Record c a -> Record c b
negate' :: (OperatorContext c, Num a) => Record c a -> Record c a
(.*.) :: (OperatorContext c, Num a) => Record c a -> Record c a -> Record c a
(./.) :: (OperatorContext c, Num a) => Record c a -> Record c a -> Record c a
(.-.) :: (OperatorContext c, Num a) => Record c a -> Record c a -> Record c a
(.+.) :: (OperatorContext c, Num a) => Record c a -> Record c a -> Record c a
likeMaybe :: (OperatorContext c, IsString a, LiteralSQL a) => Record c (Maybe a) -> a -> Record c (Maybe Bool)
like :: (OperatorContext c, IsString a, LiteralSQL a) => Record c a -> a -> Record c (Maybe Bool)
likeMaybe' :: (OperatorContext c, IsString a) => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe Bool)
like' :: (OperatorContext c, IsString a) => Record c a -> Record c a -> Record c (Maybe Bool)
(?||?) :: (OperatorContext c, IsString a) => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a)
(.||.) :: OperatorContext c => Record c a -> Record c a -> Record c a
exists :: OperatorContext c => RecordList (Record Exists) r -> Record c (Maybe Bool)
not' :: OperatorContext c => Record c (Maybe Bool) -> Record c (Maybe Bool)
or' :: OperatorContext c => Record c (Maybe Bool) -> Record c (Maybe Bool) -> Record c (Maybe Bool)
and' :: OperatorContext c => Record c (Maybe Bool) -> Record c (Maybe Bool) -> Record c (Maybe Bool)
(.<>.) :: OperatorContext c => Record c ft -> Record c ft -> Record c (Maybe Bool)
(.>=.) :: OperatorContext c => Record c ft -> Record c ft -> Record c (Maybe Bool)
(.>.) :: OperatorContext c => Record c ft -> Record c ft -> Record c (Maybe Bool)
(.<=.) :: OperatorContext c => Record c ft -> Record c ft -> Record c (Maybe Bool)
(.<.) :: OperatorContext c => Record c ft -> Record c ft -> Record c (Maybe Bool)
(.=.) :: OperatorContext c => Record c ft -> Record c ft -> Record c (Maybe Bool)
unsafeBinOp :: SqlContext k => SqlBinOp -> Record k a -> Record k b -> Record k c
unsafeUniOp :: SqlContext c2 => (Keyword -> Keyword) -> Record c1 a -> Record c2 b
unsafeShowSql :: Record c a -> String
unsafeShowSql' :: Record c a -> StringSQL
values :: (LiteralSQL t, OperatorContext c) => [t] -> RecordList (Record c) t
valueFalse :: OperatorContext c => Record c (Maybe Bool)
valueTrue :: OperatorContext c => Record c (Maybe Bool)
value :: (LiteralSQL t, OperatorContext c) => t -> Record c t
nothing :: (OperatorContext c, SqlContext c, PersistableWidth a) => Record c (Maybe a)
unsafeProjectSql :: SqlContext c => String -> Record c t
unsafeProjectSql' :: SqlContext c => StringSQL -> Record c t
type SqlBinOp = Keyword -> Keyword -> Keyword
class ProjectableMaybe (p :: Type -> Type) where
- just :: p a -> p (Maybe a)
- flattenMaybe :: p (Maybe (Maybe a)) -> p (Maybe a)
class ProjectableFlattenMaybe a b where
- flatten :: ProjectableMaybe p => p a -> p b
snd' :: (PersistableWidth a, PersistableWidth b) => Pi (a, b) b
fst' :: (PersistableWidth a, PersistableWidth b) => Pi (a, b) a
tuplePi7_6' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a7
tuplePi7_5' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a6
tuplePi7_4' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a5
tuplePi7_3' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a4
tuplePi7_2' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a3
tuplePi7_1' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a2
tuplePi7_0' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a1
tuplePi6_5' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a6
tuplePi6_4' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a5
tuplePi6_3' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a4
tuplePi6_2' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a3
tuplePi6_1' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a2
tuplePi6_0' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a1
tuplePi5_4' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5) => Pi (a1, a2, a3, a4, a5) a5
tuplePi5_3' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5) => Pi (a1, a2, a3, a4, a5) a4
tuplePi5_2' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5) => Pi (a1, a2, a3, a4, a5) a3
tuplePi5_1' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5) => Pi (a1, a2, a3, a4, a5) a2
tuplePi5_0' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5) => Pi (a1, a2, a3, a4, a5) a1
tuplePi4_3' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4) => Pi (a1, a2, a3, a4) a4
tuplePi4_2' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4) => Pi (a1, a2, a3, a4) a3
tuplePi4_1' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4) => Pi (a1, a2, a3, a4) a2
tuplePi4_0' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4) => Pi (a1, a2, a3, a4) a1
tuplePi3_2' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3) => Pi (a1, a2, a3) a3
tuplePi3_1' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3) => Pi (a1, a2, a3) a2
tuplePi3_0' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3) => Pi (a1, a2, a3) a1
tuplePi2_1' :: (PersistableWidth a1, PersistableWidth a2) => Pi (a1, a2) a2
tuplePi2_0' :: (PersistableWidth a1, PersistableWidth a2) => Pi (a1, a2) a1
updateOtherThanKeySQL :: Table r -> Pi r p -> String
type QuerySuffix = [Keyword]
list :: [p t] -> RecordList p t
data RecordList (p :: Type -> Type) t
data Table r
class PersistableWidth r => TableDerivable r where
- derivedTable :: Table r
dump :: Relation p r -> String
sqlFromRelation :: Relation p r -> StringSQL
sqlFromRelationWith :: Relation p r -> Config -> StringSQL
leftPh :: Relation (p, ()) r -> Relation p r
rightPh :: Relation ((), p) r -> Relation p r
relationWidth :: Relation p r -> PersistableRecordWidth r
untypeRelation :: Relation p r -> ConfigureQuery SubQuery
unsafeTypeRelation :: ConfigureQuery SubQuery -> Relation p r
askConfig :: ConfigureQuery Config
qualifyQuery :: a -> ConfigureQuery (Qualified a)
configureQuery :: ConfigureQuery q -> Config -> q
type ConfigureQuery = Qualify (QueryConfig Identity)
data Relation p r
class SqlContext c where
- unsafeProjectSqlTerms :: [StringSQL] -> Record c t
data PlaceHolders p
unitSQL :: SubQuery -> String
queryWidth :: Qualified SubQuery -> Int
data Order
- = Asc
- | Desc
data Nulls
- = NullsFirst
- | NullsLast
data AggregateKey a
data SubQuery
data Record c t
type Predicate c = Record c (Maybe Bool)
type PI c a b = Record c a -> Record c b
class PersistableWidth ct => ScalarDegree ct
showConstantTermsSQL :: ShowConstantTermsSQL a => a -> [StringSQL]
showConstantTermsSQL' :: ShowConstantTermsSQL a => a -> DList StringSQL
showLiteral :: LiteralSQL a => a -> [StringSQL]
class LiteralSQL a where
- showLiteral' :: a -> DList StringSQL
type ShowConstantTermsSQL = LiteralSQL
derivedUniqueKey :: HasConstraintKey Primary r ct => Key Unique r ct
uniqueKey :: PersistableWidth ct => Key Primary r ct -> Key Unique r ct
projectionKey :: Key c r ct -> Pi r ct
tableConstraint :: Key c r ct -> KeyConstraint c r
data Key c r ct
class PersistableWidth ct => HasConstraintKey c r ct where
- constraintKey :: Key c r ct
id' :: Pi a a
(<?.?>) :: Pi a (Maybe b) -> Pi b (Maybe c) -> Pi a (Maybe c)
(<?.>) :: Pi a (Maybe b) -> Pi b c -> Pi a (Maybe c)
(<.>) :: Pi a b -> Pi b c -> Pi a c
expandIndexes :: PersistableWidth a => Pi a b -> [Int]
expandIndexes' :: PersistableRecordWidth a -> Pi a b -> [Int]
data Pi r0 r1
type StringSQL = Keyword
data Flat
data Aggregated
data Exists
data OverWindow
data Set
data SetList
data Power
defaultConfig :: Config
defaultNameConfig :: NameConfig
data NameConfig
data ProductUnitSupport
- = PUSupported
- | PUNotSupported
data SchemaNameMode
- = SchemaQualified
- | SchemaNotQualified
data IdentifierQuotation
- = NoQuotation
- | Quotation Char
data Config
data Primary
data NotNull
data Unique
relationalQuery :: Relation p r -> [Keyword] -> Query p r
insertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p
insertValueNoPH :: TableDerivable r => Register r () -> Insert ()
insertQuery :: TableDerivable r => Pi r r' -> Relation p r' -> InsertQuery p
update :: TableDerivable r => (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
updateNoPH :: TableDerivable r => (Record Flat r -> Assign r ()) -> Update ()
delete :: TableDerivable r => (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
deleteNoPH :: TableDerivable r => (Record Flat r -> Restrict ()) -> Delete ()

Documentation

derivedUniqueRelation Source #

Arguments

:: TableDerivable r
=> Key Unique r k	Unique key proof object which record type is `a` and key type is `p`.
-> Record c k	Unique key value to specify.
-> UniqueRelation () c r	Result restricted `Relation`

UniqueRelation inferred from table.

primaryUpdate Source #

Arguments

:: HasConstraintKey Primary r p
=> Table r	`Table` to update
-> KeyUpdate p r	Result typed `Update`

Typed KeyUpdate using inferred primary key.

updateByConstraintKey Source #

Arguments

:: Table r	`Table` to update
-> Key c r p	Key with constraint `c`, record type `r` and columns type `p`
-> KeyUpdate p r	Result typed `Update`

Typed KeyUpdate using specified constraint key.

updateValuesWithKey :: ToSql q r => Pi r p -> r -> [q] Source #

Convert from Haskell type r into SQL value q list expected by update form like

UPDATE table SET c0 = ?, c1 = ?, ..., cn = ? WHERE key0 = ? AND key1 = ? AND key2 = ? ...

using derived RecordToSql proof object.

primary :: HasConstraintKey Primary a p => Relation () a -> Relation p a Source #

Deprecated.

primarySelect Source #

Arguments

:: HasConstraintKey Primary a p
=> Relation () a	`Relation` to add restriction.
-> Relation p a	Result restricted `Relation`

Query restricted with inferred primary key.

primary' Source #

Arguments

:: PersistableWidth p
=> Key Primary a p	Primary key proof object which record type is `a` and key type is `p`.
-> Relation () a	`Relation` to add restriction.
-> Relation p a	Result restricted `Relation`

Deprecated.

unique :: PersistableWidth p => Key Unique a p -> Relation () a -> Relation p a Source #

Deprecated.

uniqueSelect Source #

Arguments

:: PersistableWidth p
=> Key Unique a p	Unique key proof object which record type is `a` and key type is `p`.
-> Relation () a	`Relation` to add restriction.
-> Relation p a	Result restricted `Relation`

Query restricted with specified unique key.

specifiedKey Source #

Arguments

:: PersistableWidth p
=> Pi a p	Projection path
-> Relation () a	`Relation` to add restriction.
-> Relation p a	Result restricted `Relation`

Query restricted with specified key.

updateNumber Source #

Arguments

:: (PersistableWidth s, Integral i, LiteralSQL i)
=> i	sequence number to set. expect not SQL injectable.
-> Sequence s i	sequence table
-> Update ()

Update statement for sequence table

updateNumber' Source #

Arguments

:: (PersistableWidth s, Integral i, LiteralSQL i)
=> Config
-> i	sequence number to set. expect not SQL injectable.
-> Sequence s i	sequence table
-> Update ()

Update statement for sequence table

($$) Source #

Arguments

:: Binding r s i
=> (i -> r)	sequence number should be passed to proper field of record
-> Number r i
-> r

Unsafely apply sequence number. Only safe to build corresponding record type.

($$!) Source #

Arguments

:: (i -> r)	sequence number should be passed to proper field of record
-> Number r i
-> r

Unsafely apply sequence number.

extractNumber :: Number r i -> i Source #

Get untyped sequence number.

unsafeSpecifyNumber :: Binding r s i => i -> Number r i Source #

Unsafely specify sequence number.

fromRelation :: Binding r s i => Relation () r -> Sequence s i Source #

Derive Sequence from corresponding Relation

primaryBinding :: (TableDerivable r, SequenceDerivable s i, HasConstraintKey Primary r i) => SeqBinding r s i Source #

Derive binding using primary key.

unsafeSpecifyBinding :: (TableDerivable r, SequenceDerivable s i) => Pi r i -> SeqBinding r s i Source #

Unsafely specify binding between normal-table and sequence-table.

seqRelation :: TableDerivable s => Sequence s i -> Relation () s Source #

Infer Relation of sequence table

unsafeSpecifySequence :: TableDerivable s => (s -> i) -> Pi s i -> Sequence s i Source #

Unsafely specify sequence table.

data Sequence s i Source #

Basic record to express sequence-table. actual sequence-table is a table which has only one column of integer type.

class TableDerivable s => SequenceDerivable s i | s -> i where Source #

Sequence derivation rule

Methods

derivedSequence :: Sequence s i Source #

data SeqBinding r s i Source #

Record to express binding between normal-table and sequence-table.

class (TableDerivable r, SequenceDerivable s i) => Binding r s i | r -> s where Source #

Derivation rule for binding between Table and Sequence

Minimal complete definition

Nothing

Methods

binding :: SeqBinding r s i Source #

data Number r i Source #

Sequence number type for record type r

Instances

Instances details

Eq i => Eq (Number r i)
Instance details Defined in Database.Relational.Sequence Methods (==) :: Number r i -> Number r i -> Bool (/=) :: Number r i -> Number r i -> Bool
Ord i => Ord (Number r i)
Instance details Defined in Database.Relational.Sequence Methods compare :: Number r i -> Number r i -> Ordering (<) :: Number r i -> Number r i -> Bool (<=) :: Number r i -> Number r i -> Bool (>) :: Number r i -> Number r i -> Bool (>=) :: Number r i -> Number r i -> Bool max :: Number r i -> Number r i -> Number r i min :: Number r i -> Number r i -> Number r i
Show i => Show (Number r i)
Instance details Defined in Database.Relational.Sequence Methods showsPrec :: Int -> Number r i -> ShowS show :: Number r i -> String showList :: [Number r i] -> ShowS

derivedDelete :: TableDerivable r => (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p Source #

Make typed Delete from defaultConfig, derived table and Restrict computation.

derivedDelete' :: TableDerivable r => Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p Source #

Make typed Delete from Config, derived table and Restrict computation.

delete' :: TableDerivable r => Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p Source #

Make typed Delete from Config, derived table and Restrict computation.

typedDelete :: Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p Source #

Make typed Delete from Table and Restrict computation.

typedDelete' :: Config -> Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p Source #

Make typed Delete from Config, Table and Restrict computation.

deleteSQL :: Config -> Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> String Source #

Make untyped delete SQL string from Table and Restrict computation.

derivedInsertQuery :: TableDerivable r => Pi r r' -> Relation p r' -> InsertQuery p Source #

Table type inferred InsertQuery.

insertQuery' :: TableDerivable r => Config -> Pi r r' -> Relation p r' -> InsertQuery p Source #

Table type inferred InsertQuery.

typedInsertQuery :: Table r -> Pi r r' -> Relation p r' -> InsertQuery p Source #

Make typed InsertQuery from columns selector Table, Pi and Relation.

typedInsertQuery' :: Config -> Table r -> Pi r r' -> Relation p r' -> InsertQuery p Source #

Make typed InsertQuery from columns selector Table, Pi and Relation with configuration parameter.

insertQuerySQL :: Config -> Table r -> Pi r r' -> Relation p r' -> String Source #

Make untyped insert select SQL string from Table, Pi and Relation.

insertValueList :: (TableDerivable r, LiteralSQL r') => Pi r r' -> [r'] -> [Insert ()] Source #

Make typed Insert list from records list.

insertValueList' :: (TableDerivable r, LiteralSQL r') => Config -> Pi r r' -> [r'] -> [Insert ()] Source #

Make typed Insert list from Config and records list.

derivedInsertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p Source #

Make typed Insert from defaultConfig, derived table and monadic builded Register object.

derivedInsertValue' :: TableDerivable r => Config -> Register r (PlaceHolders p) -> Insert p Source #

Make typed Insert from Config, derived table and monadic builded Register object.

insertValue' :: TableDerivable r => Config -> Register r (PlaceHolders p) -> Insert p Source #

Make typed Insert from Config, derived table and monadic builded Register object.

typedInsertValue :: Table r -> InsertTarget p r -> Insert p Source #

Make typed Insert from Table and monadic builded InsertTarget object.

typedInsertValue' :: Config -> Table r -> InsertTarget p r -> Insert p Source #

Make typed Insert from Config, Table and monadic builded InsertTarget object.

derivedInsert :: (PersistableWidth r, TableDerivable r) => Pi r r' -> Insert r' Source #

Table type inferred Insert.

insert :: (PersistableWidth r, TableDerivable r) => Pi r r' -> Insert r' Source #

Table type inferred Insert.

typedInsert :: PersistableWidth r => Table r -> Pi r r' -> Insert r' Source #

Make typed Insert from Table and columns selector Pi.

typedInsert' :: PersistableWidth r => Config -> Table r -> Pi r r' -> Insert r' Source #

Make typed Insert from Table and columns selector Pi with configuration parameter.

unsafeTypedInsert' :: String -> String -> Int -> Insert a Source #

Unsafely make typed Insert from single insert and chunked insert SQL.

chunkSizeOfInsert :: Insert a -> Int Source #

Size to use chunked insert

untypeChunkInsert :: Insert a -> String Source #

Statement to use chunked insert

derivedUpdateAllColumn :: (PersistableWidth r, TableDerivable r) => (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p) Source #

Deprecated. use updateAllColumn.

updateAllColumnNoPH :: (PersistableWidth r, TableDerivable r) => (Record Flat r -> Restrict ()) -> Update r Source #

Make typed Update from defaultConfig, derived table and Restrict computation without placeholder other than target table columns. Update target is all column.

updateAllColumn :: (PersistableWidth r, TableDerivable r) => (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p) Source #

Make typed Update from defaultConfig, derived table and Restrict computation. Update target is all column.

derivedUpdateAllColumn' :: (PersistableWidth r, TableDerivable r) => Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p) Source #

Deprecated. use updateAllColumn'.

updateAllColumn' :: (PersistableWidth r, TableDerivable r) => Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p) Source #

Make typed Update from Config, derived table and Restrict computation. Update target is all column.

typedUpdateAllColumn :: PersistableWidth r => Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p) Source #

Make typed Update from Table and Restrict computation. Update target is all column.

derivedUpdate :: TableDerivable r => (Record Flat r -> Assign r (PlaceHolders p)) -> Update p Source #

Make typed Update from defaultConfig, derived table and Assign computation.

derivedUpdate' :: TableDerivable r => Config -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p Source #

Make typed Update from Config, derived table and Assign computation.

update' :: TableDerivable r => Config -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p Source #

Make typed Update from Config, derived table and Assign computation.

typedUpdate :: Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p Source #

Make typed Update using defaultConfig, Table and Assign computation.

typedUpdate' :: Config -> Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p Source #

Make typed Update from Config, Table and Assign computation.

updateSQL :: Config -> Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> String Source #

Make untyped update SQL string from Table and Assign computation.

unsafeTypedUpdate :: String -> Update p Source #

Unsafely make typed Update from SQL string.

derivedKeyUpdate :: TableDerivable r => Pi r p -> KeyUpdate p r Source #

Make typed KeyUpdate from derived table and key columns selector Pi.

keyUpdate :: TableDerivable r => Pi r p -> KeyUpdate p r Source #

Make typed KeyUpdate from derived table and key columns selector Pi.

typedKeyUpdateTable :: TableDerivable r => Relation () r -> Pi r p -> KeyUpdate p r Source #

Make typed KeyUpdate object using derived info specified by Relation type.

typedKeyUpdate :: Table a -> Pi a p -> KeyUpdate p a Source #

Make typed KeyUpdate from Table and key columns selector Pi.

relationalQuery' :: Relation p r -> QuerySuffix -> Query p r Source #

From Relation into typed Query with suffix SQL words.

relationalQuery_ :: Config -> Relation p r -> QuerySuffix -> Query p r Source #

From Relation into typed Query with suffix SQL words.

relationalQuerySQL :: Config -> Relation p r -> QuerySuffix -> String Source #

From Relation into untyped SQL query string.

unsafeTypedQuery Source #

Arguments

:: String	Query SQL to type
-> Query p a	Typed result

Unsafely make typed Query from SQL string.

newtype Query p a Source #

Query type with place-holder parameter p and query result type a.

Constructors

Query
Fields untypeQuery :: String

Instances

Instances details

Show (Query p a)	Show query SQL string
Instance details Defined in Database.Relational.Type Methods showsPrec :: Int -> Query p a -> ShowS show :: Query p a -> String showList :: [Query p a] -> ShowS

data KeyUpdate p a Source #

Update type with key type p and update record type a. Columns to update are record columns other than key columns, So place-holder parameter type is the same as record type a.

Constructors

KeyUpdate
Fields updateKey :: Pi a p untypeKeyUpdate :: String

Instances

Instances details

Show (KeyUpdate p a)	Show update SQL string
Instance details Defined in Database.Relational.Type Methods showsPrec :: Int -> KeyUpdate p a -> ShowS show :: KeyUpdate p a -> String showList :: [KeyUpdate p a] -> ShowS

newtype Update p Source #

Update type with place-holder parameter p.

Constructors

Update
Fields untypeUpdate :: String

Instances

Instances details

UntypeableNoFetch Update
Instance details Defined in Database.Relational.Type Methods untypeNoFetch :: Update p -> String Source #
Show (Update p)	Show update SQL string
Instance details Defined in Database.Relational.Type Methods showsPrec :: Int -> Update p -> ShowS show :: Update p -> String showList :: [Update p] -> ShowS

data Insert a Source #

Insert type to insert record type a.

Constructors

Insert
Fields untypeInsert :: String chunkedInsert :: Maybe (String, Int)

Instances

Instances details

UntypeableNoFetch Insert
Instance details Defined in Database.Relational.Type Methods untypeNoFetch :: Insert p -> String Source #
Show (Insert a)	Show insert SQL string.
Instance details Defined in Database.Relational.Type Methods showsPrec :: Int -> Insert a -> ShowS show :: Insert a -> String showList :: [Insert a] -> ShowS

newtype InsertQuery p Source #

InsertQuery type.

Constructors

InsertQuery
Fields untypeInsertQuery :: String

Instances

Instances details

UntypeableNoFetch InsertQuery
Instance details Defined in Database.Relational.Type Methods untypeNoFetch :: InsertQuery p -> String Source #
Show (InsertQuery p)	Show insert SQL string.
Instance details Defined in Database.Relational.Type Methods showsPrec :: Int -> InsertQuery p -> ShowS show :: InsertQuery p -> String showList :: [InsertQuery p] -> ShowS

newtype Delete p Source #

Delete type with place-holder parameter p.

Constructors

Delete
Fields untypeDelete :: String

Instances

Instances details

UntypeableNoFetch Delete
Instance details Defined in Database.Relational.Type Methods untypeNoFetch :: Delete p -> String Source #
Show (Delete p)	Show delete SQL string
Instance details Defined in Database.Relational.Type Methods showsPrec :: Int -> Delete p -> ShowS show :: Delete p -> String showList :: [Delete p] -> ShowS

class UntypeableNoFetch (s :: Type -> Type) where Source #

Untype interface for typed no-result type statments with single type parameter which represents place-holder parameter p.

Methods

untypeNoFetch :: s p -> String Source #

Instances

Instances details

UntypeableNoFetch Update
Instance details Defined in Database.Relational.Type Methods untypeNoFetch :: Update p -> String Source #
UntypeableNoFetch Insert
Instance details Defined in Database.Relational.Type Methods untypeNoFetch :: Insert p -> String Source #
UntypeableNoFetch InsertQuery
Instance details Defined in Database.Relational.Type Methods untypeNoFetch :: InsertQuery p -> String Source #
UntypeableNoFetch Delete
Instance details Defined in Database.Relational.Type Methods untypeNoFetch :: Delete p -> String Source #

sqlChunksFromRecordList :: LiteralSQL r' => Config -> Table r -> Pi r r' -> [r'] -> [StringSQL] Source #

Make StringSQL strings of SQL INSERT strings from records list

sqlFromInsertTarget :: Config -> Table r -> InsertTarget p r -> StringSQL Source #

Make StringSQL string of SQL INSERT statement from InsertTarget

sqlChunkFromInsertTarget :: Config -> Table r -> InsertTarget p r -> (StringSQL, Int) Source #

Make StringSQL string of SQL INSERT record chunk statement from InsertTarget

piRegister :: PersistableWidth r => Pi r r' -> Register r (PlaceHolders r') Source #

parametalized Register monad from Pi

insertTarget' :: Register r (PlaceHolders p) -> InsertTarget p r Source #

Finalize Register monad and generate InsertTarget with place-holder parameter p.

insertTarget :: Register r () -> InsertTarget () r Source #

Finalize Register monad and generate InsertTarget.

sqlFromUpdateTarget :: Config -> Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> StringSQL Source #

SQL SET clause and WHERE clause StringSQL string from Assign computation.

updateTargetAllColumn' :: PersistableWidth r => (Record Flat r -> Restrict (PlaceHolders p)) -> Record Flat r -> Assign r (PlaceHolders (r, p)) Source #

Deprecated.

updateTargetAllColumn :: PersistableWidth r => (Record Flat r -> Restrict ()) -> Record Flat r -> Assign r (PlaceHolders r) Source #

Deprecated.

liftTargetAllColumn' :: PersistableWidth r => (Record Flat r -> Restrict (PlaceHolders p)) -> Record Flat r -> Assign r (PlaceHolders (r, p)) Source #

Lift Restrict computation to Assign computation. Assign target columns are all. With placefolder type p.

liftTargetAllColumn :: PersistableWidth r => (Record Flat r -> Restrict (PlaceHolders ())) -> Record Flat r -> Assign r (PlaceHolders r) Source #

Lift Restrict computation to Assign computation. Assign target columns are all.

updateTarget' :: (Record Flat r -> Assign r (PlaceHolders p)) -> UpdateTarget p r Source #

Deprecated.

updateTarget :: (Record Flat r -> Assign r ()) -> UpdateTarget () r Source #

Deprecated.

sqlWhereFromRestriction :: Config -> Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> StringSQL Source #

SQL WHERE clause StringSQL string from Restrict computation.

restriction' :: (Record Flat r -> Restrict (PlaceHolders p)) -> Restriction p r Source #

Deprecated.

restriction :: (Record Flat r -> Restrict ()) -> Restriction () r Source #

Deprecated.

type Restriction p r = Record Flat r -> Restrict (PlaceHolders p) Source #

Restriction type with place-holder parameter p and projected record type r.

type UpdateTarget p r = Record Flat r -> Assign r (PlaceHolders p) Source #

UpdateTarget type with place-holder parameter p and projected record type r.

data InsertTarget p r Source #

InsertTarget type with place-holder parameter p and projected record type r.

intersectAll' :: Relation p a -> Relation q a -> Relation (p, q) a infixl 8 Source #

Intersection of two relations with place-holder parameters. Not distinct.

intersect' :: Relation p a -> Relation q a -> Relation (p, q) a infixl 8 Source #

Intersection of two relations with place-holder parameters.

exceptAll' :: Relation p a -> Relation q a -> Relation (p, q) a infixl 7 Source #

Subtraction of two relations with place-holder parameters. Not distinct.

except' :: Relation p a -> Relation q a -> Relation (p, q) a infixl 7 Source #

Subtraction of two relations with place-holder parameters.

unionAll' :: Relation p a -> Relation q a -> Relation (p, q) a infixl 7 Source #

Union of two relations with place-holder parameters. Not distinct.

union' :: Relation p a -> Relation q a -> Relation (p, q) a infixl 7 Source #

Union of two relations with place-holder parameters.

intersectAll :: Relation () a -> Relation () a -> Relation () a infixl 8 Source #

Intersection of two relations. Not distinct.

intersect :: Relation () a -> Relation () a -> Relation () a infixl 8 Source #

Intersection of two relations.

exceptAll :: Relation () a -> Relation () a -> Relation () a infixl 7 Source #

Subtraction of two relations. Not distinct.

except :: Relation () a -> Relation () a -> Relation () a infixl 7 Source #

Subtraction of two relations.

unionAll :: Relation () a -> Relation () a -> Relation () a infixl 7 Source #

Union of two relations. Not distinct.

union :: Relation () a -> Relation () a -> Relation () a infixl 7 Source #

Union of two relations.

on' :: ([JoinRestriction a b] -> Relation pc (a, b)) -> [JoinRestriction a b] -> Relation pc (a, b) infixl 8 Source #

Apply restriction for direct join style.

full infixl 8 Source #

Arguments

:: Relation () a	Left query to join
-> Relation () b	Right query to join
-> [JoinRestriction (Maybe a) (Maybe b)]	Join restrictions
-> Relation () (Maybe a, Maybe b)	Result joined relation

Direct full outer join.

right infixl 8 Source #

Arguments

:: Relation () a	Left query to join
-> Relation () b	Right query to join
-> [JoinRestriction (Maybe a) b]	Join restrictions
-> Relation () (Maybe a, b)	Result joined relation

Direct right outer join.

left infixl 8 Source #

Arguments

:: Relation () a	Left query to join
-> Relation () b	Right query to join
-> [JoinRestriction a (Maybe b)]	Join restrictions
-> Relation () (a, Maybe b)	Result joined relation

Direct left outer join.

inner infixl 8 Source #

Arguments

:: Relation () a	Left query to join
-> Relation () b	Right query to join
-> [JoinRestriction a b]	Join restrictions
-> Relation () (a, b)	Result joined relation

Direct inner join.

full' infixl 8 Source #

Arguments

:: Relation pa a	Left query to join
-> Relation pb b	Right query to join
-> [JoinRestriction (Maybe a) (Maybe b)]	Join restrictions
-> Relation (pa, pb) (Maybe a, Maybe b)	Result joined relation

Direct full outer join with place-holder parameters.

right' infixl 8 Source #

Arguments

:: Relation pa a	Left query to join
-> Relation pb b	Right query to join
-> [JoinRestriction (Maybe a) b]	Join restrictions
-> Relation (pa, pb) (Maybe a, b)	Result joined relation

Direct right outer join with place-holder parameters.

left' infixl 8 Source #

Arguments

:: Relation pa a	Left query to join
-> Relation pb b	Right query to join
-> [JoinRestriction a (Maybe b)]	Join restrictions
-> Relation (pa, pb) (a, Maybe b)	Result joined relation

Direct left outer join with place-holder parameters.

inner' infixl 8 Source #

Arguments

:: Relation pa a	Left query to join
-> Relation pb b	Right query to join
-> [JoinRestriction a b]	Join restrictions
-> Relation (pa, pb) (a, b)	Result joined relation

Direct inner join with place-holder parameters.

type JoinRestriction a b = Record Flat a -> Record Flat b -> Predicate Flat Source #

Restriction predicate function type for direct style join operator, used on predicates of direct join style as follows.

  do xy <- query $
           relX inner relY on` [ x y -> ... ] -- this lambda form has JoinRestriction type
     ...

queryScalar :: (MonadQualify ConfigureQuery m, ScalarDegree r) => UniqueRelation () c r -> m (Record c (Maybe r)) Source #

Scalar sub-query.

queryScalar' :: (MonadQualify ConfigureQuery m, ScalarDegree r) => UniqueRelation p c r -> m (PlaceHolders p, Record c (Maybe r)) Source #

Scalar sub-query with place-holder parameter p.

aggregatedUnique :: Relation ph r -> Pi r a -> (Record Flat a -> Record Aggregated b) -> UniqueRelation ph Flat b Source #

Aggregated UniqueRelation.

uniqueRelation' :: QueryUnique (PlaceHolders p, Record c r) -> UniqueRelation p c r Source #

Finalize QueryUnique monad and generate UniqueRelation.

uniqueQueryMaybe' :: UniqueRelation p c r -> QueryUnique (PlaceHolders p, Record c (Maybe r)) Source #

Join unique sub-query with place-holder parameter p. Query result is Maybe.

uniqueQuery' :: UniqueRelation p c r -> QueryUnique (PlaceHolders p, Record c r) Source #

Join unique sub-query with place-holder parameter p.

unUnique :: UniqueRelation p c r -> Relation p r Source #

Discard unique attribute.

unsafeUnique :: Relation p r -> UniqueRelation p c r Source #

Unsafely specify unique relation.

aggregateRelation :: QueryAggregate (Record Aggregated r) -> Relation () r Source #

Finalize QueryAggregate monad and geneate Relation.

aggregateRelation' :: AggregatedQuery p r -> Relation p r Source #

Finalize QueryAggregate monad and geneate Relation with place-holder parameter p.

relation :: QuerySimple (Record Flat r) -> Relation () r Source #

Finalize QuerySimple monad and generate Relation.

relation' :: SimpleQuery p r -> Relation p r Source #

Finalize QuerySimple monad and generate Relation with place-holder parameter p.

queryList :: MonadQualify ConfigureQuery m => Relation () r -> m (RecordList (Record c) r) Source #

List sub-query, for IN and EXIST.

queryList' :: MonadQualify ConfigureQuery m => Relation p r -> m (PlaceHolders p, RecordList (Record c) r) Source #

List sub-query, for IN and EXIST with place-holder parameter p.

queryMaybe :: (MonadQualify ConfigureQuery m, MonadQuery m) => Relation () r -> m (Record Flat (Maybe r)) Source #

Join sub-query. Query result is Maybe. The combinations of query and queryMaybe express inner joins, left outer joins, right outer joins, and full outer joins. Here is an example of a right outer join:

  outerJoin = relation $ do
    e <- queryMaybe employee
    d <- query department
    on $ e ?! E.deptId' .=. just (d ! D.deptId')
    return $ (,) |$| e |*| d

query :: (MonadQualify ConfigureQuery m, MonadQuery m) => Relation () r -> m (Record Flat r) Source #

Join sub-query. Query result is not Maybe.

tableOf :: TableDerivable r => Relation () r -> Table r Source #

Interface to derive Table type object.

derivedRelation :: TableDerivable r => Relation () r Source #

Inferred Relation.

table :: Table r -> Relation () r Source #

Simple Relation from Table.

data UniqueRelation p c r Source #

Unique relation type to compose scalar queries.

over :: SqlContext c => Record OverWindow a -> Window c () -> Record c a infix 8 Source #

Operator to make record of window function result using built Window monad.

type QueryAggregate = Orderings Aggregated (Restrictings Aggregated (AggregatingSetT QueryCore)) Source #

Aggregated query monad type.

type AggregatedQuery p r = OrderedQuery Aggregated (Restrictings Aggregated (AggregatingSetT QueryCore)) p r Source #

Aggregated query type. AggregatedQuery p r == QueryAggregate (PlaceHolders p, Record Aggregated r).

type Window c = Orderings c (PartitioningSet c) Source #

Partition monad type for partition-by clause.

groupingSets :: AggregatingSetList a -> AggregateKey a Source #

Finalize grouping set list.

cube :: AggregatingPowerSet a -> AggregateKey a Source #

Finalize grouping power set as cube power set.

rollup :: AggregatingPowerSet a -> AggregateKey a Source #

Finalize grouping power set as rollup power set.

bkey :: Record Flat r -> AggregatingPowerSet (Record Aggregated (Maybe r)) Source #

Specify key of rollup and cube power set.

set :: AggregatingSet a -> AggregatingSetList a Source #

Finalize and specify single grouping set.

key' :: AggregateKey a -> AggregatingSet a Source #

Specify key of single grouping set.

key :: Record Flat r -> AggregatingSet (Record Aggregated (Maybe r)) Source #

Specify key of single grouping set from Record.

type Assign r = Assignings r Restrict Source #

Target update monad type used from update statement and merge statement.

type Register r = Assignings r ConfigureQuery Source #

Target register monad type used from insert statement.

(<-#) :: forall (m :: Type -> Type) r v. Monad m => AssignTarget r v -> Record Flat v -> Assignings r m () infix 4 Source #

Add and assginment.

assignTo :: forall (m :: Type -> Type) v r. Monad m => Record Flat v -> AssignTarget r v -> Assignings r m () Source #

Add an assignment.

type QuerySimple = Orderings Flat QueryCore Source #

Simple (not-aggregated) query monad type.

type SimpleQuery p r = OrderedQuery Flat QueryCore p r Source #

Simple (not-aggregated) query type. SimpleQuery' p r == QuerySimple (PlaceHolders p, Record r).

data QueryUnique a Source #

Unique query monad type.

Instances

Instances details

Monad QueryUnique
Instance details Defined in Database.Relational.Monad.Unique Methods (>>=) :: QueryUnique a -> (a -> QueryUnique b) -> QueryUnique b (>>) :: QueryUnique a -> QueryUnique b -> QueryUnique b return :: a -> QueryUnique a
Functor QueryUnique
Instance details Defined in Database.Relational.Monad.Unique Methods fmap :: (a -> b) -> QueryUnique a -> QueryUnique b (<$) :: a -> QueryUnique b -> QueryUnique a
Applicative QueryUnique
Instance details Defined in Database.Relational.Monad.Unique Methods pure :: a -> QueryUnique a (<>) :: QueryUnique (a -> b) -> QueryUnique a -> QueryUnique b liftA2 :: (a -> b -> c) -> QueryUnique a -> QueryUnique b -> QueryUnique c (>) :: QueryUnique a -> QueryUnique b -> QueryUnique b (<*) :: QueryUnique a -> QueryUnique b -> QueryUnique a
MonadQuery QueryUnique
Instance details Defined in Database.Relational.Monad.Unique Methods setDuplication :: Duplication -> QueryUnique () Source # restrictJoin :: Predicate Flat -> QueryUnique () Source # query' :: Relation p r -> QueryUnique (PlaceHolders p, Record Flat r) Source # queryMaybe' :: Relation p r -> QueryUnique (PlaceHolders p, Record Flat (Maybe r)) Source #
MonadQualify ConfigureQuery QueryUnique
Instance details Defined in Database.Relational.Monad.Unique Methods liftQualify :: ConfigureQuery a -> QueryUnique a Source #

extractCore :: QueryCore a -> ConfigureQuery (((a, [Predicate Flat]), JoinProduct), Duplication) Source #

Extract QueryCore computation.

type QueryCore = Restrictings Flat (QueryJoin ConfigureQuery) Source #

Core query monad type used from flat(not-aggregated) query and aggregated query.

type OrderedQuery c (m :: Type -> Type) p r = Orderings c m (PlaceHolders p, Record c r) Source #

OrderedQuery monad type with placeholder type p. Record must be the same as Orderings context type parameter c.

desc Source #

Arguments

:: forall (m :: Type -> Type) c t. Monad m
=> Record c t	Ordering terms to add
-> Orderings c m ()	Result context with ordering

Add descendant ordering term.

asc Source #

Arguments

:: forall (m :: Type -> Type) c t. Monad m
=> Record c t	Ordering terms to add
-> Orderings c m ()	Result context with ordering

Add ascendant ordering term.

orderBy Source #

Arguments

:: forall (m :: Type -> Type) c t. Monad m
=> Record c t	Ordering terms to add
-> Order	Order direction
-> Orderings c m ()	Result context with ordering

Add ordering terms.

orderBy' Source #

Arguments

:: forall (m :: Type -> Type) c t. Monad m
=> Record c t	Ordering terms to add
-> Order	Order direction
-> Nulls	Order of null
-> Orderings c m ()	Result context with ordering

Add ordering terms with null ordering.

data Orderings c (m :: Type -> Type) a Source #

Type to accumulate ordering context. Type c is ordering term record context type.

Instances

Instances details

MonadRestrict rc m => MonadRestrict rc (Orderings c m)	`MonadRestrict` with ordering.
Instance details Defined in Database.Relational.Monad.Trans.Ordering Methods restrict :: Predicate rc -> Orderings c m () Source #
MonadQualify q m => MonadQualify q (Orderings c m)	`MonadQualify` with ordering.
Instance details Defined in Database.Relational.Monad.Trans.Ordering Methods liftQualify :: q a -> Orderings c m a Source #
MonadPartition c m => MonadPartition c (Orderings c m)	`MonadPartition` with ordering.
Instance details Defined in Database.Relational.Monad.Trans.Ordering Methods partitionBy :: Record c r -> Orderings c m () Source #
MonadTrans (Orderings c)
Instance details Defined in Database.Relational.Monad.Trans.Ordering Methods lift :: Monad m => m a -> Orderings c m a
Monad m => Monad (Orderings c m)
Instance details Defined in Database.Relational.Monad.Trans.Ordering Methods (>>=) :: Orderings c m a -> (a -> Orderings c m b) -> Orderings c m b (>>) :: Orderings c m a -> Orderings c m b -> Orderings c m b return :: a -> Orderings c m a
Functor m => Functor (Orderings c m)
Instance details Defined in Database.Relational.Monad.Trans.Ordering Methods fmap :: (a -> b) -> Orderings c m a -> Orderings c m b (<$) :: a -> Orderings c m b -> Orderings c m a
Applicative m => Applicative (Orderings c m)
Instance details Defined in Database.Relational.Monad.Trans.Ordering Methods pure :: a -> Orderings c m a (<>) :: Orderings c m (a -> b) -> Orderings c m a -> Orderings c m b liftA2 :: (a -> b -> c0) -> Orderings c m a -> Orderings c m b -> Orderings c m c0 (>) :: Orderings c m a -> Orderings c m b -> Orderings c m b (<*) :: Orderings c m a -> Orderings c m b -> Orderings c m a
MonadQuery m => MonadQuery (Orderings c m)	`MonadQuery` with ordering.
Instance details Defined in Database.Relational.Monad.Trans.Ordering Methods setDuplication :: Duplication -> Orderings c m () Source # restrictJoin :: Predicate Flat -> Orderings c m () Source # query' :: Relation p r -> Orderings c m (PlaceHolders p, Record Flat r) Source # queryMaybe' :: Relation p r -> Orderings c m (PlaceHolders p, Record Flat (Maybe r)) Source #
MonadAggregate m => MonadAggregate (Orderings c m)	`MonadAggregate` with ordering.
Instance details Defined in Database.Relational.Monad.Trans.Ordering Methods groupBy :: Record Flat r -> Orderings c m (Record Aggregated r) Source # groupBy' :: AggregateKey (Record Aggregated r) -> Orderings c m (Record Aggregated r) Source #

type Restrict = Restrictings Flat ConfigureQuery Source #

Restrict only monad type used from update statement and delete statement.

having :: MonadRestrict Aggregated m => Predicate Aggregated -> m () Source #

Add restriction to this aggregated query. Aggregated Record type version.

wheres :: MonadRestrict Flat m => Predicate Flat -> m () Source #

Add restriction to this not aggregated query.

on :: MonadQuery m => Predicate Flat -> m () Source #

Add restriction to last join. Record type version.

distinct :: MonadQuery m => m () Source #

Specify DISTINCT attribute to query context.

all' :: MonadQuery m => m () Source #

Specify ALL attribute to query context.

class (Functor m, Monad m) => MonadRestrict c (m :: Type -> Type) where Source #

Restrict context interface

Methods

restrict Source #

Arguments

:: Predicate c	`Record` which represent restriction
-> m ()	Restricted query context

Add restriction to this context.

Instances

Instances details

MonadRestrict c m => MonadRestrict c (AggregatingSetT m)	Aggregated `MonadRestrict`.
Instance details Defined in Database.Relational.Monad.Trans.Aggregating Methods restrict :: Predicate c -> AggregatingSetT m () Source #
MonadRestrict rc m => MonadRestrict rc (Orderings c m)	`MonadRestrict` with ordering.
Instance details Defined in Database.Relational.Monad.Trans.Ordering Methods restrict :: Predicate rc -> Orderings c m () Source #
(Monad q, Functor q) => MonadRestrict c (Restrictings c q)	`MonadRestrict` instance.
Instance details Defined in Database.Relational.Monad.Trans.Restricting Methods restrict :: Predicate c -> Restrictings c q () Source #
MonadRestrict c m => MonadRestrict c (Assignings r m)	`MonadRestrict` with assigning.
Instance details Defined in Database.Relational.Monad.Trans.Assigning Methods restrict :: Predicate c -> Assignings r m () Source #

class (Functor m, Monad m, MonadQualify ConfigureQuery m) => MonadQuery (m :: Type -> Type) where Source #

Query building interface.

Minimal complete definition

setDuplication, restrictJoin, query', queryMaybe'

Methods

query' :: Relation p r -> m (PlaceHolders p, Record Flat r) Source #

Join sub-query with place-holder parameter p. query result is not Maybe.

queryMaybe' :: Relation p r -> m (PlaceHolders p, Record Flat (Maybe r)) Source #

Join sub-query with place-holder parameter p. Query result is Maybe.

Instances

Instances details

MonadQuery QueryUnique
Instance details Defined in Database.Relational.Monad.Unique Methods setDuplication :: Duplication -> QueryUnique () Source # restrictJoin :: Predicate Flat -> QueryUnique () Source # query' :: Relation p r -> QueryUnique (PlaceHolders p, Record Flat r) Source # queryMaybe' :: Relation p r -> QueryUnique (PlaceHolders p, Record Flat (Maybe r)) Source #
MonadQuery m => MonadQuery (AggregatingSetT m)	Aggregated `MonadQuery`.
Instance details Defined in Database.Relational.Monad.Trans.Aggregating Methods setDuplication :: Duplication -> AggregatingSetT m () Source # restrictJoin :: Predicate Flat -> AggregatingSetT m () Source # query' :: Relation p r -> AggregatingSetT m (PlaceHolders p, Record Flat r) Source # queryMaybe' :: Relation p r -> AggregatingSetT m (PlaceHolders p, Record Flat (Maybe r)) Source #
MonadQuery (QueryJoin ConfigureQuery)	Joinable query instance.
Instance details Defined in Database.Relational.Monad.Trans.Join Methods setDuplication :: Duplication -> QueryJoin ConfigureQuery () Source # restrictJoin :: Predicate Flat -> QueryJoin ConfigureQuery () Source # query' :: Relation p r -> QueryJoin ConfigureQuery (PlaceHolders p, Record Flat r) Source # queryMaybe' :: Relation p r -> QueryJoin ConfigureQuery (PlaceHolders p, Record Flat (Maybe r)) Source #
MonadQuery m => MonadQuery (Orderings c m)	`MonadQuery` with ordering.
Instance details Defined in Database.Relational.Monad.Trans.Ordering Methods setDuplication :: Duplication -> Orderings c m () Source # restrictJoin :: Predicate Flat -> Orderings c m () Source # query' :: Relation p r -> Orderings c m (PlaceHolders p, Record Flat r) Source # queryMaybe' :: Relation p r -> Orderings c m (PlaceHolders p, Record Flat (Maybe r)) Source #
MonadQuery q => MonadQuery (Restrictings c q)	Restricted `MonadQuery` instance.
Instance details Defined in Database.Relational.Monad.Trans.Restricting Methods setDuplication :: Duplication -> Restrictings c q () Source # restrictJoin :: Predicate Flat -> Restrictings c q () Source # query' :: Relation p r -> Restrictings c q (PlaceHolders p, Record Flat r) Source # queryMaybe' :: Relation p r -> Restrictings c q (PlaceHolders p, Record Flat (Maybe r)) Source #

class (Functor q, Monad q, Functor m, Monad m) => MonadQualify (q :: Type -> Type) (m :: Type -> Type) Source #

Lift interface from base qualify monad.

Minimal complete definition

liftQualify

Instances

Instances details

(Functor q, Monad q) => MonadQualify q q
Instance details Defined in Database.Relational.Monad.Class Methods liftQualify :: q a -> q a Source #
MonadQualify ConfigureQuery QueryUnique
Instance details Defined in Database.Relational.Monad.Unique Methods liftQualify :: ConfigureQuery a -> QueryUnique a Source #
MonadQualify q m => MonadQualify q (QueryJoin m)
Instance details Defined in Database.Relational.Monad.Trans.Join Methods liftQualify :: q a -> QueryJoin m a Source #
MonadQualify q m => MonadQualify q (AggregatingSetT m)	Aggregated `MonadQualify`.
Instance details Defined in Database.Relational.Monad.Trans.Aggregating Methods liftQualify :: q a -> AggregatingSetT m a Source #
MonadQualify q m => MonadQualify q (Orderings c m)	`MonadQualify` with ordering.
Instance details Defined in Database.Relational.Monad.Trans.Ordering Methods liftQualify :: q a -> Orderings c m a Source #
MonadQualify q m => MonadQualify q (Restrictings c m)	Restricted `MonadQualify` instance.
Instance details Defined in Database.Relational.Monad.Trans.Restricting Methods liftQualify :: q a -> Restrictings c m a Source #
MonadQualify q m => MonadQualify q (Assignings r m)	`MonadQualify` with assigning.
Instance details Defined in Database.Relational.Monad.Trans.Assigning Methods liftQualify :: q a -> Assignings r m a Source #

class MonadQuery m => MonadAggregate (m :: Type -> Type) where Source #

Aggregated query building interface extends MonadQuery.

Methods

groupBy Source #

Arguments

:: Record Flat r	Record to add into group by
-> m (Record Aggregated r)	Result context and aggregated record \| Add GROUP BY term into context and get aggregated record. Non-traditional group-by version.

Add GROUP BY term into context and get aggregated record.

groupBy' Source #

Arguments

:: AggregateKey (Record Aggregated r)	Key to aggretate for non-traditional group-by interface
-> m (Record Aggregated r)	Result context and aggregated record

Instances

Instances details

MonadQuery m => MonadAggregate (AggregatingSetT m)	Aggregated query instance.
Instance details Defined in Database.Relational.Monad.Trans.Aggregating Methods groupBy :: Record Flat r -> AggregatingSetT m (Record Aggregated r) Source # groupBy' :: AggregateKey (Record Aggregated r) -> AggregatingSetT m (Record Aggregated r) Source #
MonadAggregate m => MonadAggregate (Orderings c m)	`MonadAggregate` with ordering.
Instance details Defined in Database.Relational.Monad.Trans.Ordering Methods groupBy :: Record Flat r -> Orderings c m (Record Aggregated r) Source # groupBy' :: AggregateKey (Record Aggregated r) -> Orderings c m (Record Aggregated r) Source #
MonadAggregate m => MonadAggregate (Restrictings c m)	Resticted `MonadAggregate` instance.
Instance details Defined in Database.Relational.Monad.Trans.Restricting Methods groupBy :: Record Flat r -> Restrictings c m (Record Aggregated r) Source # groupBy' :: AggregateKey (Record Aggregated r) -> Restrictings c m (Record Aggregated r) Source #

class Monad m => MonadPartition c (m :: Type -> Type) where Source #

Window specification building interface.

Methods

partitionBy :: Record c r -> m () Source #

Add PARTITION BY term into context.

Instances

Instances details

MonadPartition c m => MonadPartition c (Orderings c m)	`MonadPartition` with ordering.
Instance details Defined in Database.Relational.Monad.Trans.Ordering Methods partitionBy :: Record c r -> Orderings c m () Source #
Monad m => MonadPartition c (PartitioningSetT c m)	Partition clause instance
Instance details Defined in Database.Relational.Monad.Trans.Aggregating Methods partitionBy :: Record c r -> PartitioningSetT c m () Source #

(??) infixl 8 Source #

Arguments

:: 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

Same as (?!?). Use this operator like '(?? #foo) mayX'.

(?) infixl 8 Source #

Arguments

:: 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

Same as (?!). Use this operator like '(? #foo) mayX'.

(!??) infixl 8 Source #

Arguments

:: (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.

Get narrower record with flatten leaf phantom Maybe types along with projection path.

flattenPiMaybe Source #

Arguments

:: (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

Get narrower record with flatten leaf phantom Maybe types along with projection path.

(?!?) infixl 8 Source #

Arguments

:: 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

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.

(?!) infixl 8 Source #

Arguments

:: 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

Get narrower record along with projection path Maybe phantom functor is map-ed.

(!) infixl 8 Source #

Arguments

:: PersistableWidth a
=> Record c a	Source `Record`
-> Pi a b	Record path
-> Record c b	Narrower projected object

Get narrower record along with projection path.

some' :: (AggregatedContext ac, SqlContext ac) => Predicate Flat -> Record ac (Maybe Bool) Source #

Aggregation function SOME.

any' :: (AggregatedContext ac, SqlContext ac) => Predicate Flat -> Record ac (Maybe Bool) Source #

Aggregation function ANY.

every :: (AggregatedContext ac, SqlContext ac) => Predicate Flat -> Record ac (Maybe Bool) Source #

Aggregation function EVERY.

min' :: (Ord a, AggregatedContext ac, SqlContext ac) => Record Flat a -> Record ac (Maybe a) Source #

Aggregation function MIN.

minMaybe :: (Ord a, AggregatedContext ac, SqlContext ac) => Record Flat (Maybe a) -> Record ac (Maybe a) Source #

Aggregation function MIN.

max' :: (Ord a, AggregatedContext ac, SqlContext ac) => Record Flat a -> Record ac (Maybe a) Source #

Aggregation function MAX.

maxMaybe :: (Ord a, AggregatedContext ac, SqlContext ac) => Record Flat (Maybe a) -> Record ac (Maybe a) Source #

Aggregation function MAX.

avg :: (Num a, Fractional b, AggregatedContext ac, SqlContext ac) => Record Flat a -> Record ac (Maybe b) Source #

Aggregation function AVG.

avgMaybe :: (Num a, Fractional b, AggregatedContext ac, SqlContext ac) => Record Flat (Maybe a) -> Record ac (Maybe b) Source #

Aggregation function AVG.

sum' :: (Num a, AggregatedContext ac, SqlContext ac) => Record Flat a -> Record ac (Maybe a) Source #

Aggregation function SUM.

sumMaybe :: (Num a, AggregatedContext ac, SqlContext ac) => Record Flat (Maybe a) -> Record ac (Maybe a) Source #

Aggregation function SUM.

count :: (Integral b, AggregatedContext ac, SqlContext ac) => Record Flat a -> Record ac b Source #

Aggregation function COUNT.

unsafeAggregateOp :: (AggregatedContext ac, SqlContext ac) => Keyword -> Record Flat a -> Record ac b Source #

Unsafely make aggregation uni-operator from SQL keyword.

(><) :: ProductIsoApplicative p => p a -> p b -> p (a, b) infixl 1 Source #

Binary operator the same as projectZip.

projectZip :: ProductIsoApplicative p => p a -> p b -> p (a, b) Source #

Zipping projections.

placeholder :: (PersistableWidth t, SqlContext c, Monad m) => (Record c t -> m a) -> m (PlaceHolders t, a) Source #

Provide scoped placeholder and return its parameter object. Monadic version.

placeholder' :: (PersistableWidth t, SqlContext c) => (Record c t -> a) -> (PlaceHolders t, a) Source #

Provide scoped placeholder and return its parameter object.

pwPlaceholder :: SqlContext c => PersistableRecordWidth a -> (Record c a -> b) -> (PlaceHolders a, b) Source #

Provide scoped placeholder from width and return its parameter object.

unitPH :: PlaceHolders () Source #

No placeholder semantics. Same as unitPlaceHolder

unitPlaceHolder :: PlaceHolders () Source #

No placeholder semantics

unsafePlaceHolders :: PlaceHolders p Source #

Unsafely get placeholder parameter

unsafeAddPlaceHolders :: Functor f => f a -> f (PlaceHolders p, a) Source #

Unsafely add placeholder parameter to queries.

cumeDist :: Record OverWindow Double Source #

CUME_DIST() term.

percentRank :: Record OverWindow Double Source #

PERCENT_RANK() term.

rowNumber :: Integral a => Record OverWindow a Source #

ROW_NUMBER() term.

denseRank :: Integral a => Record OverWindow a Source #

DENSE_RANK() term.

rank :: Integral a => Record OverWindow a Source #

RANK() term.

fromMaybe :: (OperatorContext c, HasColumnConstraint NotNull r) => Record c r -> Record c (Maybe r) -> Record c r Source #

Operator from maybe type using record extended isNull.

isJust :: (OperatorContext c, HasColumnConstraint NotNull r) => Record c (Maybe r) -> Predicate c Source #

Operator corresponding SQL NOT (... IS NULL) , and extended against record type.

isNothing :: (OperatorContext c, HasColumnConstraint NotNull r) => Record c (Maybe r) -> Predicate c Source #

Operator corresponding SQL IS NULL , and extended against record types.

in' :: OperatorContext c => Record c t -> RecordList (Record c) t -> Record c (Maybe Bool) infix 4 Source #

Binary operator corresponding SQL IN .

caseMaybe Source #

Arguments

:: (OperatorContext c, 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

Null default version of case'.

casesOrElse' Source #

Arguments

:: 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

Uncurry version of case', and you can write like ... casesOrElse` clause.

case' Source #

Arguments

:: 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

Simple case operator correnponding SQL simple CASE. Like, CASE x WHEN v THEN a WHEN w THEN b ... ELSE c END

caseSearchMaybe Source #

Arguments

:: (OperatorContext c, PersistableWidth a)
=> [(Predicate c, Record c (Maybe a))]	Each when clauses
-> Record c (Maybe a)	Result record

Null default version of caseSearch.

casesOrElse Source #

Arguments

:: OperatorContext c
=> [(Predicate c, Record c a)]	Each when clauses
-> Record c a	Else result record
-> Record c a	Result record

Same as caseSearch, but you can write like list casesOrElse clause.

caseSearch Source #

Arguments

:: OperatorContext c
=> [(Predicate c, Record c a)]	Each when clauses
-> Record c a	Else result record
-> Record c a	Result record

Search case operator correnponding SQL search CASE. Like, CASE WHEN p0 THEN a WHEN p1 THEN b ... ELSE c END

showNumMaybe :: (SqlContext c, Num a, IsString b) => Record c (Maybe a) -> Record c (Maybe b) Source #

Unsafely show number into string-like type in records.

fromIntegralMaybe :: (SqlContext c, Integral a, Num b) => Record c (Maybe a) -> Record c (Maybe b) Source #

Number fromIntegral uni-operator.

negateMaybe :: (OperatorContext c, Num a) => Record c (Maybe a) -> Record c (Maybe a) Source #

Number negate uni-operator corresponding SQL -.

(?*?) :: (OperatorContext c, Num a) => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a) infixl 7 Source #

Number operator corresponding SQL * .

(?/?) :: (OperatorContext c, Num a) => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a) infixl 7 Source #

Number operator corresponding SQL /// .

(?-?) :: (OperatorContext c, Num a) => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a) infixl 6 Source #

Number operator corresponding SQL - .

(?+?) :: (OperatorContext c, Num a) => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a) infixl 6 Source #

Number operator corresponding SQL + .

showNum :: (SqlContext c, Num a, IsString b) => Record c a -> Record c b Source #

Unsafely show number into string-like type in records.

fromIntegral' :: (SqlContext c, Integral a, Num b) => Record c a -> Record c b Source #

Number fromIntegral uni-operator.

negate' :: (OperatorContext c, Num a) => Record c a -> Record c a Source #

Number negate uni-operator corresponding SQL -.

(.*.) :: (OperatorContext c, Num a) => Record c a -> Record c a -> Record c a infixl 7 Source #

Number operator corresponding SQL * .

(./.) :: (OperatorContext c, Num a) => Record c a -> Record c a -> Record c a infixl 7 Source #

Number operator corresponding SQL /// .

(.-.) :: (OperatorContext c, Num a) => Record c a -> Record c a -> Record c a infixl 6 Source #

Number operator corresponding SQL - .

(.+.) :: (OperatorContext c, Num a) => Record c a -> Record c a -> Record c a infixl 6 Source #

Number operator corresponding SQL + .

likeMaybe :: (OperatorContext c, IsString a, LiteralSQL a) => Record c (Maybe a) -> a -> Record c (Maybe Bool) infix 4 Source #

String-compare operator corresponding SQL LIKE . Maybe type version.

like :: (OperatorContext c, IsString a, LiteralSQL a) => Record c a -> a -> Record c (Maybe Bool) infix 4 Source #

String-compare operator corresponding SQL LIKE .

likeMaybe' :: (OperatorContext c, IsString a) => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe Bool) infix 4 Source #

String-compare operator corresponding SQL LIKE .

like' :: (OperatorContext c, IsString a) => Record c a -> Record c a -> Record c (Maybe Bool) infix 4 Source #

String-compare operator corresponding SQL LIKE .

(?||?) :: (OperatorContext c, IsString a) => Record c (Maybe a) -> Record c (Maybe a) -> Record c (Maybe a) infixl 5 Source #

Concatinate operator corresponding SQL || . Maybe type version.

(.||.) :: OperatorContext c => Record c a -> Record c a -> Record c a infixl 5 Source #

Concatinate operator corresponding SQL || .

exists :: OperatorContext c => RecordList (Record Exists) r -> Record c (Maybe Bool) Source #

Logical operator corresponding SQL EXISTS .

not' :: OperatorContext c => Record c (Maybe Bool) -> Record c (Maybe Bool) Source #

Logical operator corresponding SQL NOT .

or' :: OperatorContext c => Record c (Maybe Bool) -> Record c (Maybe Bool) -> Record c (Maybe Bool) infixr 2 Source #

Logical operator corresponding SQL OR .

and' :: OperatorContext c => Record c (Maybe Bool) -> Record c (Maybe Bool) -> Record c (Maybe Bool) infixr 3 Source #

Logical operator corresponding SQL AND .

(.<>.) :: OperatorContext c => Record c ft -> Record c ft -> Record c (Maybe Bool) infix 4 Source #

Compare operator corresponding SQL <> .

(.>=.) :: OperatorContext c => Record c ft -> Record c ft -> Record c (Maybe Bool) infix 4 Source #

Compare operator corresponding SQL >= .

(.>.) :: OperatorContext c => Record c ft -> Record c ft -> Record c (Maybe Bool) infix 4 Source #

Compare operator corresponding SQL > .

(.<=.) :: OperatorContext c => Record c ft -> Record c ft -> Record c (Maybe Bool) infix 4 Source #

Compare operator corresponding SQL <= .

(.<.) :: OperatorContext c => Record c ft -> Record c ft -> Record c (Maybe Bool) infix 4 Source #

Compare operator corresponding SQL < .

(.=.) :: OperatorContext c => Record c ft -> Record c ft -> Record c (Maybe Bool) infix 4 Source #

Compare operator corresponding SQL = .

unsafeBinOp :: SqlContext k => SqlBinOp -> Record k a -> Record k b -> Record k c Source #

Unsafely make binary operator for records from string binary operator.

unsafeUniOp :: SqlContext c2 => (Keyword -> Keyword) -> Record c1 a -> Record c2 b Source #

Unsafely make unary operator for records from SQL keyword.

unsafeShowSql Source #

Arguments

:: Record c a	Source record object
-> String	Result SQL expression string.

Unsafely generate SQL expression string from record object. String interface of unsafeShowSql'.

unsafeShowSql' :: Record c a -> StringSQL Source #

Unsafely generate SQL expression term from record object.

values :: (LiteralSQL t, OperatorContext c) => [t] -> RecordList (Record c) t Source #

RecordList with polymorphic type of SQL set value from Haskell list.

valueFalse :: OperatorContext c => Record c (Maybe Bool) Source #

Record with polymorphic type of SQL false value.

valueTrue :: OperatorContext c => Record c (Maybe Bool) Source #

Record with polymorphic type of SQL true value.

value :: (LiteralSQL t, OperatorContext c) => t -> Record c t Source #

Generate record with polymorphic type of SQL constant values from Haskell value.

nothing :: (OperatorContext c, SqlContext c, PersistableWidth a) => Record c (Maybe a) Source #

Record with polymorphic phantom type of SQL null value. Semantics of comparing is unsafe.

unsafeProjectSql :: SqlContext c => String -> Record c t Source #

Unsafely Project single SQL string. String interface of unsafeProjectSql''.

unsafeProjectSql' :: SqlContext c => StringSQL -> Record c t Source #

Unsafely Project single SQL term.

type SqlBinOp = Keyword -> Keyword -> Keyword Source #

Binary operator type for SQL String.

class ProjectableMaybe (p :: Type -> Type) where Source #

Interface to control Maybe of phantom type in records.

Methods

just :: p a -> p (Maybe a) Source #

Cast record phantom type into Maybe.

flattenMaybe :: p (Maybe (Maybe a)) -> p (Maybe a) Source #

Compose nested Maybe phantom type on record.

Instances

Instances details

ProjectableMaybe PlaceHolders	Control phantom `Maybe` type in placeholder parameters.
Instance details Defined in Database.Relational.Projectable Methods just :: PlaceHolders a -> PlaceHolders (Maybe a) Source # flattenMaybe :: PlaceHolders (Maybe (Maybe a)) -> PlaceHolders (Maybe a) Source #
ProjectableMaybe (Record c)	Control phantom `Maybe` type in record type `Record`.
Instance details Defined in Database.Relational.Projectable Methods just :: Record c a -> Record c (Maybe a) Source # flattenMaybe :: Record c (Maybe (Maybe a)) -> Record c (Maybe a) Source #

class ProjectableFlattenMaybe a b where Source #

Interface to compose phantom Maybe nested type.

Methods

flatten :: ProjectableMaybe p => p a -> p b Source #

Instances

Instances details

ProjectableFlattenMaybe (Maybe a) b => ProjectableFlattenMaybe (Maybe (Maybe a)) b	Compose `Maybe` type in record phantom type.
Instance details Defined in Database.Relational.Projectable Methods flatten :: ProjectableMaybe p => p (Maybe (Maybe a)) -> p b Source #
ProjectableFlattenMaybe (Maybe a) (Maybe a)	Not `Maybe` type is not processed.
Instance details Defined in Database.Relational.Projectable Methods flatten :: ProjectableMaybe p => p (Maybe a) -> p (Maybe a) Source #

snd' :: (PersistableWidth a, PersistableWidth b) => Pi (a, b) b Source #

Projection path for snd of tuple.

fst' :: (PersistableWidth a, PersistableWidth b) => Pi (a, b) a Source #

Projection path for fst of tuple.

tuplePi7_6' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a7 Source #

tuplePi7_5' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a6 Source #

tuplePi7_4' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a5 Source #

tuplePi7_3' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a4 Source #

tuplePi7_2' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a3 Source #

tuplePi7_1' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a2 Source #

tuplePi7_0' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a1 Source #

tuplePi6_5' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a6 Source #

tuplePi6_4' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a5 Source #

tuplePi6_3' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a4 Source #

tuplePi6_2' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a3 Source #

tuplePi6_1' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a2 Source #

tuplePi6_0' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a1 Source #

tuplePi5_4' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5) => Pi (a1, a2, a3, a4, a5) a5 Source #

tuplePi5_3' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5) => Pi (a1, a2, a3, a4, a5) a4 Source #

tuplePi5_2' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5) => Pi (a1, a2, a3, a4, a5) a3 Source #

tuplePi5_1' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5) => Pi (a1, a2, a3, a4, a5) a2 Source #

tuplePi5_0' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5) => Pi (a1, a2, a3, a4, a5) a1 Source #

tuplePi4_3' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4) => Pi (a1, a2, a3, a4) a4 Source #

tuplePi4_2' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4) => Pi (a1, a2, a3, a4) a3 Source #

tuplePi4_1' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4) => Pi (a1, a2, a3, a4) a2 Source #

tuplePi4_0' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4) => Pi (a1, a2, a3, a4) a1 Source #

tuplePi3_2' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3) => Pi (a1, a2, a3) a3 Source #

tuplePi3_1' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3) => Pi (a1, a2, a3) a2 Source #

tuplePi3_0' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3) => Pi (a1, a2, a3) a1 Source #

tuplePi2_1' :: (PersistableWidth a1, PersistableWidth a2) => Pi (a1, a2) a2 Source #

tuplePi2_0' :: (PersistableWidth a1, PersistableWidth a2) => Pi (a1, a2) a1 Source #

updateOtherThanKeySQL Source #

Arguments

:: Table r	Table metadata
-> Pi r p	Key columns
-> String	Result SQL

Generate update SQL specified by single key.

type QuerySuffix = [Keyword] Source #

Type for query suffix words

list :: [p t] -> RecordList p t Source #

Make projected record list from Record list.

data RecordList (p :: Type -> Type) t Source #

Projected record list type for row list.

data Table r Source #

Phantom typed table type

Instances

Instances details

Show (Table r)
Instance details Defined in Database.Relational.Table Methods showsPrec :: Int -> Table r -> ShowS show :: Table r -> String showList :: [Table r] -> ShowS

class PersistableWidth r => TableDerivable r where Source #

Inference rule of Table existence.

Methods

derivedTable :: Table r Source #

Instances

Instances details

TableDerivable Columns Source #
Instance details Defined in Database.Relational.Schema.IBMDB2.Columns Methods derivedTable :: Table Columns Source #
TableDerivable Columns Source #
Instance details Defined in Database.Relational.Schema.MySQL.Columns Methods derivedTable :: Table Columns Source #
TableDerivable DbaTabColumns Source #
Instance details Defined in Database.Relational.Schema.Oracle.TabColumns Methods derivedTable :: Table DbaTabColumns Source #
TableDerivable PgAttribute Source #
Instance details Defined in Database.Relational.Schema.PostgreSQL.PgAttribute Methods derivedTable :: Table PgAttribute Source #
TableDerivable PgType Source #
Instance details Defined in Database.Relational.Schema.PostgreSQL.PgType Methods derivedTable :: Table PgType Source #
TableDerivable Columns Source #
Instance details Defined in Database.Relational.Schema.SQLServer.Columns Methods derivedTable :: Table Columns Source #
TableDerivable Types Source #
Instance details Defined in Database.Relational.Schema.SQLServer.Types Methods derivedTable :: Table Types Source #
TableDerivable IndexInfo Source #
Instance details Defined in Database.Relational.Schema.SQLite3.IndexInfo Methods derivedTable :: Table IndexInfo Source #
TableDerivable IndexList Source #
Instance details Defined in Database.Relational.Schema.SQLite3.IndexList Methods derivedTable :: Table IndexList Source #
TableDerivable TableInfo Source #
Instance details Defined in Database.Relational.Schema.SQLite3.TableInfo Methods derivedTable :: Table TableInfo Source #

dump :: Relation p r -> String Source #

Dump internal structure tree.

sqlFromRelation :: Relation p r -> StringSQL Source #

SQL string from Relation.

sqlFromRelationWith :: Relation p r -> Config -> StringSQL Source #

Generate SQL string from Relation with configuration.

leftPh :: Relation (p, ()) r -> Relation p r Source #

Simplify placeholder type applying right identity element.

rightPh :: Relation ((), p) r -> Relation p r Source #

Simplify placeholder type applying left identity element.

relationWidth :: Relation p r -> PersistableRecordWidth r Source #

PersistableRecordWidth of Relation type.

untypeRelation :: Relation p r -> ConfigureQuery SubQuery Source #

Sub-query Qualify monad from relation.

unsafeTypeRelation :: ConfigureQuery SubQuery -> Relation p r Source #

Unsafely type qualified subquery into record typed relation type.

askConfig :: ConfigureQuery Config Source #

Read configuration.

qualifyQuery :: a -> ConfigureQuery (Qualified a) Source #

Get qualifyed table form query.

configureQuery :: ConfigureQuery q -> Config -> q Source #

Run ConfigureQuery monad with initial state to get only result.

type ConfigureQuery = Qualify (QueryConfig Identity) Source #

Thin monad type for untyped structure.

data Relation p r Source #

Relation type with place-holder parameter p and query result type r.

Instances

Instances details

Show (Relation p r)
Instance details Defined in Database.Relational.Monad.BaseType Methods showsPrec :: Int -> Relation p r -> ShowS show :: Relation p r -> String showList :: [Relation p r] -> ShowS

class SqlContext c where Source #

Interface to project SQL terms unsafely.

Methods

unsafeProjectSqlTerms :: [StringSQL] -> Record c t Source #

Unsafely project from SQL expression terms.

data PlaceHolders p Source #

Placeholder parameter type which has real parameter type arguemnt p.

Instances

Instances details

ProjectableMaybe PlaceHolders	Control phantom `Maybe` type in placeholder parameters.
Instance details Defined in Database.Relational.Projectable Methods just :: PlaceHolders a -> PlaceHolders (Maybe a) Source # flattenMaybe :: PlaceHolders (Maybe (Maybe a)) -> PlaceHolders (Maybe a) Source #

unitSQL :: SubQuery -> String Source #

SQL string for nested-qeury.

queryWidth :: Qualified SubQuery -> Int Source #

Width of Qualified SubQUery.

data Order Source #

Order direction. Ascendant or Descendant.

Constructors

Asc
Desc

Instances

Instances details

Show Order
Instance details Defined in Database.Relational.SqlSyntax.Types Methods showsPrec :: Int -> Order -> ShowS show :: Order -> String showList :: [Order] -> ShowS

data Nulls Source #

Order of null.

Constructors

NullsFirst
NullsLast

Instances

Instances details

Show Nulls
Instance details Defined in Database.Relational.SqlSyntax.Types Methods showsPrec :: Int -> Nulls -> ShowS show :: Nulls -> String showList :: [Nulls] -> ShowS

data AggregateKey a Source #

Typeful aggregate element.

data SubQuery Source #

Sub-query type

Instances

Instances details

Show SubQuery
Instance details Defined in Database.Relational.SqlSyntax.Types Methods showsPrec :: Int -> SubQuery -> ShowS show :: SubQuery -> String showList :: [SubQuery] -> ShowS

data Record c t Source #

Phantom typed record. Projected into Haskell record type t.

Instances

Instances details

ProjectableMaybe (Record c)	Control phantom `Maybe` type in record type `Record`.
Instance details Defined in Database.Relational.Projectable Methods just :: Record c a -> Record c (Maybe a) Source # flattenMaybe :: Record c (Maybe (Maybe a)) -> Record c (Maybe a) Source #
Show (Record c t)
Instance details Defined in Database.Relational.SqlSyntax.Types Methods showsPrec :: Int -> Record c t -> ShowS show :: Record c t -> String showList :: [Record c t] -> ShowS

type Predicate c = Record c (Maybe Bool) Source #

Type for predicate to restrict of query result.

type PI c a b = Record c a -> Record c b Source #

Type for projection function.

class PersistableWidth ct => ScalarDegree ct Source #

Constraint which represents scalar degree.

Instances

Instances details

ScalarDegree ct => ScalarDegree (Maybe ct)
Instance details Defined in Database.Relational.Scalar

showConstantTermsSQL :: ShowConstantTermsSQL a => a -> [StringSQL] Source #

Deprecated.

showConstantTermsSQL' :: ShowConstantTermsSQL a => a -> DList StringSQL Source #

showLiteral :: LiteralSQL a => a -> [StringSQL] Source #

Convert from haskell record to SQL literal row-value.

class LiteralSQL a where Source #

LiteralSQL a is implicit rule to derive function to convert from haskell record type a into SQL literal row-value.

Generic programming (https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#generic-programming) with default signature is available for LiteralSQL class, so you can make instance like below:

  {-# LANGUAGE DeriveGeneric #-}
  import GHC.Generics (Generic)
  --
  data Foo = Foo { ... } deriving Generic
  instance LiteralSQL Foo

Minimal complete definition

Nothing

Methods

showLiteral' :: a -> DList StringSQL Source #

Instances

Instances details

LiteralSQL Columns Source #
Instance details Defined in Database.Relational.Schema.IBMDB2.Columns Methods showLiteral' :: Columns -> DList StringSQL Source #
LiteralSQL Columns Source #
Instance details Defined in Database.Relational.Schema.MySQL.Columns Methods showLiteral' :: Columns -> DList StringSQL Source #
LiteralSQL DbaTabColumns Source #
Instance details Defined in Database.Relational.Schema.Oracle.TabColumns Methods showLiteral' :: DbaTabColumns -> DList StringSQL Source #
LiteralSQL PgAttribute Source #
Instance details Defined in Database.Relational.Schema.PostgreSQL.PgAttribute Methods showLiteral' :: PgAttribute -> DList StringSQL Source #
LiteralSQL PgType Source #
Instance details Defined in Database.Relational.Schema.PostgreSQL.PgType Methods showLiteral' :: PgType -> DList StringSQL Source #
LiteralSQL Columns Source #
Instance details Defined in Database.Relational.Schema.SQLServer.Columns Methods showLiteral' :: Columns -> DList StringSQL Source #
LiteralSQL Types Source #
Instance details Defined in Database.Relational.Schema.SQLServer.Types Methods showLiteral' :: Types -> DList StringSQL Source #
LiteralSQL IndexInfo Source #
Instance details Defined in Database.Relational.Schema.SQLite3.IndexInfo Methods showLiteral' :: IndexInfo -> DList StringSQL Source #
LiteralSQL IndexList Source #
Instance details Defined in Database.Relational.Schema.SQLite3.IndexList Methods showLiteral' :: IndexList -> DList StringSQL Source #
LiteralSQL TableInfo Source #
Instance details Defined in Database.Relational.Schema.SQLite3.TableInfo Methods showLiteral' :: TableInfo -> DList StringSQL Source #

type ShowConstantTermsSQL = LiteralSQL Source #

Deprecated.

derivedUniqueKey :: HasConstraintKey Primary r ct => Key Unique r ct Source #

Inferred Unique constraint Key. Record type r has unique key which type is ct derived from primay key.

uniqueKey :: PersistableWidth ct => Key Primary r ct -> Key Unique r ct Source #

Derive Unique constraint Key from Primary constraint Key

projectionKey :: Key c r ct -> Pi r ct Source #

Get projection path proof object from constraint Key.

tableConstraint :: Key c r ct -> KeyConstraint c r Source #

Get table constraint KeyConstraint proof object from constraint Key.

data Key c r ct Source #

Constraint Key proof object. Constraint type c, record type r and columns type ct.

class PersistableWidth ct => HasConstraintKey c r ct where Source #

Constraint Key inference interface.

Methods

constraintKey :: Key c r ct Source #

Infer constraint key.

id' :: Pi a a Source #

Identity projection path.

(<?.?>) :: Pi a (Maybe b) -> Pi b (Maybe c) -> Pi a (Maybe c) infixl 8 Source #

Compose projection path. Maybe phantom functors are join-ed like >=>.

(<?.>) :: Pi a (Maybe b) -> Pi b c -> Pi a (Maybe c) infixl 8 Source #

Compose projection path. Maybe phantom functor is map-ed.

(<.>) :: Pi a b -> Pi b c -> Pi a c infixl 8 Source #

Compose projection path.

expandIndexes :: PersistableWidth a => Pi a b -> [Int] Source #

Expand indexes from key. Infered width version.

expandIndexes' :: PersistableRecordWidth a -> Pi a b -> [Int] Source #

Expand indexes from key.

data Pi r0 r1 Source #

Projection path from type r0 into type r1. This type also indicate key object which type is r1 for record type r0.

Instances

Instances details

ProductIsoApplicative (Pi a)	Compose projection path `Pi` which has record result type using applicative style.
Instance details Defined in Database.Relational.Pi.Unsafe Methods pureP :: ProductConstructor a0 => a0 -> Pi a a0 (\|*\|) :: Pi a (a0 -> b) -> Pi a a0 -> Pi a b
ProductIsoFunctor (Pi a)	Map projection path `Pi` which has record result type.
Instance details Defined in Database.Relational.Pi.Unsafe Methods (\|$\|) :: ProductConstructor (a0 -> b) => (a0 -> b) -> Pi a a0 -> Pi a b
ProductIsoEmpty (Pi a) ()
Instance details Defined in Database.Relational.Pi.Unsafe Methods pureE :: Pi a () peRight :: Pi a (a0, ()) -> Pi a a0 peLeft :: Pi a ((), a0) -> Pi a a0
Category Pi
Instance details Defined in Database.Relational.Pi.Unsafe Methods id :: forall (a :: k). Pi a a (.) :: forall (b :: k) (c :: k) (a :: k). Pi b c -> Pi a b -> Pi a c
PersistableWidth r0 => Show (Pi r0 r1)
Instance details Defined in Database.Relational.Pi.Unsafe Methods showsPrec :: Int -> Pi r0 r1 -> ShowS show :: Pi r0 r1 -> String showList :: [Pi r0 r1] -> ShowS

type StringSQL = Keyword Source #

String wrap type for SQL strings.

data Flat Source #

Type tag for flat (not-aggregated) query

data Aggregated Source #

Type tag for aggregated query

data Exists Source #

Type tag for exists predicate

data OverWindow Source #

Type tag for window function building

data Set Source #

Type tag for normal aggregatings set

Instances

Instances details

MonadRestrict c m => MonadRestrict c (AggregatingSetT m)	Aggregated `MonadRestrict`.
Instance details Defined in Database.Relational.Monad.Trans.Aggregating Methods restrict :: Predicate c -> AggregatingSetT m () Source #
MonadQualify q m => MonadQualify q (AggregatingSetT m)	Aggregated `MonadQualify`.
Instance details Defined in Database.Relational.Monad.Trans.Aggregating Methods liftQualify :: q a -> AggregatingSetT m a Source #
MonadQuery m => MonadQuery (AggregatingSetT m)	Aggregated `MonadQuery`.
Instance details Defined in Database.Relational.Monad.Trans.Aggregating Methods setDuplication :: Duplication -> AggregatingSetT m () Source # restrictJoin :: Predicate Flat -> AggregatingSetT m () Source # query' :: Relation p r -> AggregatingSetT m (PlaceHolders p, Record Flat r) Source # queryMaybe' :: Relation p r -> AggregatingSetT m (PlaceHolders p, Record Flat (Maybe r)) Source #
MonadQuery m => MonadAggregate (AggregatingSetT m)	Aggregated query instance.
Instance details Defined in Database.Relational.Monad.Trans.Aggregating Methods groupBy :: Record Flat r -> AggregatingSetT m (Record Aggregated r) Source # groupBy' :: AggregateKey (Record Aggregated r) -> AggregatingSetT m (Record Aggregated r) Source #

data SetList Source #

Type tag for aggregatings GROUPING SETS

data Power Source #

Type tag for aggregatings power set

defaultConfig :: Config Source #

Default configuration of Config. To change some behaviour of relational-query, use record update syntax:

  defaultConfig
    { productUnitSupport            =  PUSupported
    , chunksInsertSize              =  256
    , schemaNameMode                =  SchemaQualified
    , normalizedTableName           =  True
    , addQueryTableAliasAS          =  False
    , addModifyTableAliasAS         =  False
    , enableWarning                 =  True
    , verboseAsCompilerWarning      =  False
    , disableOverloadedProjection   =  False
    , disableSpecializedProjection  =  False
    , identifierQuotation           =  NoQuotation
    , nameConfig                    =
       defaultNameConfig
       { recordConfig     =  defaultNameConfig
       , relationVarName  =  \schema table -> varCamelcaseName $ table ++ "_" ++ scheme
       -- ^ append the table name after the schema name. e.g. "schemaTable"
       }
    }

defaultNameConfig :: NameConfig Source #

Default implementation of NameConfig type.

data NameConfig Source #

NameConfig type to customize names of expanded templates.

Instances

Instances details

Show NameConfig
Instance details Defined in Database.Relational.Internal.Config Methods showsPrec :: Int -> NameConfig -> ShowS show :: NameConfig -> String showList :: [NameConfig] -> ShowS

data ProductUnitSupport Source #

Unit of product is supported or not.

Constructors

PUSupported
PUNotSupported

Instances

Instances details

Show ProductUnitSupport
Instance details Defined in Database.Relational.Internal.Config Methods showsPrec :: Int -> ProductUnitSupport -> ShowS show :: ProductUnitSupport -> String showList :: [ProductUnitSupport] -> ShowS

data SchemaNameMode Source #

Schema name qualify mode in SQL string.

Constructors

SchemaQualified	Schema qualified table name in SQL string
SchemaNotQualified	Not qualified table name in SQL string

Instances

Instances details

Eq SchemaNameMode
Instance details Defined in Database.Relational.Internal.Config Methods (==) :: SchemaNameMode -> SchemaNameMode -> Bool (/=) :: SchemaNameMode -> SchemaNameMode -> Bool
Show SchemaNameMode
Instance details Defined in Database.Relational.Internal.Config Methods showsPrec :: Int -> SchemaNameMode -> ShowS show :: SchemaNameMode -> String showList :: [SchemaNameMode] -> ShowS

data IdentifierQuotation Source #

Configuration for quotation of identifiers of SQL.

Constructors

NoQuotation
Quotation Char

Instances

Instances details

Show IdentifierQuotation
Instance details Defined in Database.Relational.Internal.Config Methods showsPrec :: Int -> IdentifierQuotation -> ShowS show :: IdentifierQuotation -> String showList :: [IdentifierQuotation] -> ShowS

data Config Source #

Configuration type.

Instances

Instances details

Show Config
Instance details Defined in Database.Relational.Internal.Config Methods showsPrec :: Int -> Config -> ShowS show :: Config -> String showList :: [Config] -> ShowS

data Primary #

data NotNull #

Instances

Instances details

HasColumnConstraint NotNull a => HasColumnConstraint NotNull (a, b)
Instance details Defined in Database.Record.KeyConstraint Methods columnConstraint :: ColumnConstraint NotNull (a, b)

data Unique #

relationalQuery Source #

Arguments

:: Relation p r	relation to finalize building
-> [Keyword]	suffix SQL words. for example, `[FOR, UPDATE]`, `[FETCH, FIRST, "3", ROWS, ONLY]` ...
-> Query p r	finalized query

From Relation into typed Query with suffix SQL words.

insertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p Source #

Make Insert from derived table and monadic builded Register object.

insertValueNoPH :: TableDerivable r => Register r () -> Insert () Source #

Make Insert from derived table and monadic builded Register object with no(unit) placeholder.

insertQuery :: TableDerivable r => Pi r r' -> Relation p r' -> InsertQuery p Source #

Make InsertQuery from derived table, Pi and Relation.

update :: TableDerivable r => (Record Flat r -> Assign r (PlaceHolders p)) -> Update p Source #

Make Update from derived table and Assign computation.

updateNoPH :: TableDerivable r => (Record Flat r -> Assign r ()) -> Update () Source #

Make Update from derived table and Assign computation with no(unit) placeholder.

delete :: TableDerivable r => (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p Source #

Make Delete from derived table and Restrict computation.

deleteNoPH :: TableDerivable r => (Record Flat r -> Restrict ()) -> Delete () Source #

Make Delete from defaultConfig, derived table and Restrict computation with no(unit) placeholder.