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

Database.Relational.Arrow

Contents

Deprecated

Description

This module defines arrow version combinators which improves type-safty on building queries. Referencing the local projected records may cause to break the result query. It is possible to controls injection of previous local projected records by restricting domain type of arrow. This idea is imported from Opaleye:

Importing this module instead of Database.Relational.Query enables to build query using arrow combinators.

Synopsis

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

Documentation

data Unique Source #

Constraint type. Unique key.

data NotNull Source #

Constraint type. Not-null key.

Instances

Instances details

HasColumnConstraint NotNull a => HasColumnConstraint NotNull (a, b)	Inference rule of `ColumnConstraint` `NotNull` for tuple (,) type.
Instance details Defined in Database.Record.KeyConstraint Methods columnConstraint :: ColumnConstraint NotNull (a, b) Source #

data Primary Source #

Constraint type. Primary key.

data Config Source #

Configuration type.

Instances

Instances details

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

data IdentifierQuotation Source #

Configuration for quotation of identifiers of SQL.

Constructors

NoQuotation
Quotation Char

Instances

Instances details

Show IdentifierQuotation Source #
Instance details Defined in Database.Relational.Internal.Config Methods showsPrec :: Int -> IdentifierQuotation -> ShowS show :: IdentifierQuotation -> String showList :: [IdentifierQuotation] -> 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 Source #
Instance details Defined in Database.Relational.Internal.Config Methods (==) :: SchemaNameMode -> SchemaNameMode -> Bool (/=) :: SchemaNameMode -> SchemaNameMode -> Bool
Show SchemaNameMode Source #
Instance details Defined in Database.Relational.Internal.Config Methods showsPrec :: Int -> SchemaNameMode -> ShowS show :: SchemaNameMode -> String showList :: [SchemaNameMode] -> ShowS

data ProductUnitSupport Source #

Unit of product is supported or not.

Constructors

PUSupported
PUNotSupported

Instances

Instances details

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

data NameConfig Source #

NameConfig type to customize names of expanded templates.

Instances

Instances details

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

defaultNameConfig :: NameConfig Source #

Default implementation of NameConfig type.

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"
       }
    }

data Power Source #

Type tag for aggregatings power set

data SetList Source #

Type tag for aggregatings GROUPING SETS

data Set Source #

Type tag for normal aggregatings set

Instances

Instances details

MonadQualify q m => MonadQualify q (AggregatingSetT m) Source #	Aggregated `MonadQualify`.
Instance details Defined in Database.Relational.Monad.Trans.Aggregating Methods liftQualify :: q a -> AggregatingSetT m a Source #
MonadRestrict c m => MonadRestrict c (AggregatingSetT m) Source #	Aggregated `MonadRestrict`.
Instance details Defined in Database.Relational.Monad.Trans.Aggregating Methods restrict :: Predicate c -> AggregatingSetT m () Source #
MonadQuery m => MonadAggregate (AggregatingSetT m) Source #	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 #
MonadQuery m => MonadQuery (AggregatingSetT m) Source #	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 #

data OverWindow Source #

Type tag for window function building

Instances

Instances details

AggregatedContext OverWindow Source #	`OverWindow` context is aggregated context
Instance details Defined in Database.Relational.Projectable.Instances
SqlContext OverWindow Source #	Unsafely make `Record` from SQL terms.
Instance details Defined in Database.Relational.Projectable.Instances Methods unsafeProjectSqlTerms :: [StringSQL] -> Record OverWindow t Source #

data Exists Source #

Type tag for exists predicate

data Aggregated Source #

Type tag for aggregated query

Instances

Instances details

AggregatedContext Aggregated Source #	`Aggregated` context is aggregated context
Instance details Defined in Database.Relational.Projectable.Instances
OperatorContext Aggregated Source #	full SQL expression is availabe in Aggregated context
Instance details Defined in Database.Relational.Projectable.Instances
SqlContext Aggregated Source #	Unsafely make `Record` from SQL terms.
Instance details Defined in Database.Relational.Projectable.Instances Methods unsafeProjectSqlTerms :: [StringSQL] -> Record Aggregated t Source #
MonadRestrict Flat q => MonadRestrict Flat (Restrictings Aggregated q) Source #	Restricted `MonadRestrict` instance.
Instance details Defined in Database.Relational.Monad.Aggregate Methods restrict :: Predicate Flat -> Restrictings Aggregated q () Source #

data Flat Source #

Type tag for flat (not-aggregated) query

Instances

Instances details

OperatorContext Flat Source #	full SQL expression is availabe in Flat context
Instance details Defined in Database.Relational.Projectable.Instances
SqlContext Flat Source #	Unsafely make `Record` from SQL terms.
Instance details Defined in Database.Relational.Projectable.Instances Methods unsafeProjectSqlTerms :: [StringSQL] -> Record Flat t Source #
MonadRestrict Flat q => MonadRestrict Flat (Restrictings Aggregated q) Source #	Restricted `MonadRestrict` instance.
Instance details Defined in Database.Relational.Monad.Aggregate Methods restrict :: Predicate Flat -> Restrictings Aggregated q () Source #
TableDerivable r => Show (Record Flat r -> Assign r (PlaceHolders p))	Show Set clause and WHERE clause.
Instance details Defined in Database.Relational.Effect Methods showsPrec :: Int -> (Record Flat r -> Assign r (PlaceHolders p)) -> ShowS show :: (Record Flat r -> Assign r (PlaceHolders p)) -> String showList :: [Record Flat r -> Assign r (PlaceHolders p)] -> ShowS
TableDerivable r => Show (Record Flat r -> Restrict (PlaceHolders p))	Show WHERE clause.
Instance details Defined in Database.Relational.Effect Methods showsPrec :: Int -> (Record Flat r -> Restrict (PlaceHolders p)) -> ShowS show :: (Record Flat r -> Restrict (PlaceHolders p)) -> String showList :: [Record Flat r -> Restrict (PlaceHolders p)] -> ShowS

type StringSQL = Keyword Source #

String wrap type for SQL strings.

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

HasProjection l a b => IsLabel l (Pi a b)	Derive `IsLabel` instance from `HasProjection`.
Instance details Defined in Database.Relational.OverloadedProjection Methods fromLabel :: Pi a b
ProductIsoFunctor (Pi a) Source #	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 Source #
ProductIsoApplicative (Pi a) Source #	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 Source # (\|*\|) :: Pi a (a0 -> b) -> Pi a a0 -> Pi a b Source #
ProductIsoEmpty (Pi a) () Source #
Instance details Defined in Database.Relational.Pi.Unsafe Methods pureE :: Pi a () Source # peRight :: Pi a (a0, ()) -> Pi a a0 Source # peLeft :: Pi a ((), a0) -> Pi a a0 Source #
Category Pi Source #
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) Source #
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

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

Expand indexes from key.

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

Expand indexes from key. Infered width version.

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

Compose projection path.

(<?.>) :: 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 (Maybe b) -> Pi b (Maybe c) -> Pi a (Maybe c) infixl 8 Source #

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

id' :: Pi a a Source #

Identity projection path.

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

Constraint Key inference interface.

Methods

constraintKey :: Key c r ct Source #

Infer constraint key.

data Key c r ct Source #

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

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

Get table constraint KeyConstraint proof object from constraint Key.

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

Get projection path proof object from constraint Key.

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

Derive Unique constraint Key from Primary constraint Key

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.

type ShowConstantTermsSQL = LiteralSQL Source #

Deprecated: Use LiteralSQL instead of this.

Deprecated.

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 #

default showLiteral' :: (Generic a, GLiteralSQL (Rep a)) => a -> DList StringSQL Source #

Instances

Instances details

LiteralSQL Bool Source #	Constant SQL terms of `Bool`.
Instance details Defined in Database.Relational.Pure Methods showLiteral' :: Bool -> DList StringSQL Source #
LiteralSQL Char Source #	Constant SQL terms of `Char`.
Instance details Defined in Database.Relational.Pure Methods showLiteral' :: Char -> DList StringSQL Source #
LiteralSQL Double Source #	Constant SQL terms of `Double`. Caution for floating-point error rate.
Instance details Defined in Database.Relational.Pure Methods showLiteral' :: Double -> DList StringSQL Source #
LiteralSQL Float Source #	Constant SQL terms of `Float`. Caution for floating-point error rate.
Instance details Defined in Database.Relational.Pure Methods showLiteral' :: Float -> DList StringSQL Source #
LiteralSQL Int Source #	Constant SQL terms of `Int`. Use this carefully, because this is architecture dependent size of integer type.
Instance details Defined in Database.Relational.Pure Methods showLiteral' :: Int -> DList StringSQL Source #
LiteralSQL Int8 Source #	Constant SQL terms of `Int8`.
Instance details Defined in Database.Relational.Pure Methods showLiteral' :: Int8 -> DList StringSQL Source #
LiteralSQL Int16 Source #	Constant SQL terms of `Int16`.
Instance details Defined in Database.Relational.Pure Methods showLiteral' :: Int16 -> DList StringSQL Source #
LiteralSQL Int32 Source #	Constant SQL terms of `Int32`.
Instance details Defined in Database.Relational.Pure Methods showLiteral' :: Int32 -> DList StringSQL Source #
LiteralSQL Int64 Source #	Constant SQL terms of `Int64`.
Instance details Defined in Database.Relational.Pure Methods showLiteral' :: Int64 -> DList StringSQL Source #
LiteralSQL Integer Source #
Instance details Defined in Database.Relational.Pure Methods showLiteral' :: Integer -> DList StringSQL Source #
LiteralSQL Word Source #	Constant SQL terms of `Word`. Use this carefully, because this is architecture dependent size of integer type.
Instance details Defined in Database.Relational.Pure Methods showLiteral' :: Word -> DList StringSQL Source #
LiteralSQL Word8 Source #	Constant SQL terms of `Word8`.
Instance details Defined in Database.Relational.Pure Methods showLiteral' :: Word8 -> DList StringSQL Source #
LiteralSQL Word16 Source #	Constant SQL terms of `Word16`.
Instance details Defined in Database.Relational.Pure Methods showLiteral' :: Word16 -> DList StringSQL Source #
LiteralSQL Word32 Source #	Constant SQL terms of `Word32`.
Instance details Defined in Database.Relational.Pure Methods showLiteral' :: Word32 -> DList StringSQL Source #
LiteralSQL Word64 Source #	Constant SQL terms of `Word64`.
Instance details Defined in Database.Relational.Pure Methods showLiteral' :: Word64 -> DList StringSQL Source #
LiteralSQL () Source #	Constant SQL terms of `()`.
Instance details Defined in Database.Relational.Pure Methods showLiteral' :: () -> DList StringSQL Source #
LiteralSQL String Source #	Constant SQL terms of `String`.
Instance details Defined in Database.Relational.Pure Methods showLiteral' :: String -> DList StringSQL Source #
LiteralSQL Day Source #	Constant SQL terms of `Day`.
Instance details Defined in Database.Relational.Pure Methods showLiteral' :: Day -> DList StringSQL Source #
LiteralSQL UTCTime Source #	Constant SQL terms of `UTCTime`. This generates *NOT STANDARD* SQL of TIMESTAMPTZ literal with UTC timezone.
Instance details Defined in Database.Relational.NonStandard.PureTimestampTZ Methods showLiteral' :: UTCTime -> DList StringSQL Source #
LiteralSQL LocalTime Source #	Constant SQL terms of `LocalTime`.
Instance details Defined in Database.Relational.Pure Methods showLiteral' :: LocalTime -> DList StringSQL Source #
LiteralSQL TimeOfDay Source #	Constant SQL terms of `TimeOfDay`.
Instance details Defined in Database.Relational.Pure Methods showLiteral' :: TimeOfDay -> DList StringSQL Source #
LiteralSQL ZonedTime Source #	Constant SQL terms of `ZonedTime`. This generates *NOT STANDARD* SQL of TIMESTAMPTZ literal.
Instance details Defined in Database.Relational.NonStandard.PureTimestampTZ Methods showLiteral' :: ZonedTime -> DList StringSQL Source #
LiteralSQL Text Source #	Constant SQL terms of `Text`.
Instance details Defined in Database.Relational.Pure Methods showLiteral' :: Text -> DList StringSQL Source #
LiteralSQL ByteString Source #	Constant SQL terms of `ByteString`.
Instance details Defined in Database.Relational.PureUTF8 Methods showLiteral' :: ByteString -> DList StringSQL Source #
LiteralSQL Text Source #	Constant SQL terms of `Text`.
Instance details Defined in Database.Relational.Pure Methods showLiteral' :: Text -> DList StringSQL Source #
LiteralSQL ByteString Source #	Constant SQL terms of `ByteString`.
Instance details Defined in Database.Relational.PureUTF8 Methods showLiteral' :: ByteString -> DList StringSQL Source #
(PersistableWidth a, LiteralSQL a) => LiteralSQL (Maybe a) Source #	Constant SQL terms of `Maybe` type. Width inference is required.
Instance details Defined in Database.Relational.Pure Methods showLiteral' :: Maybe a -> DList StringSQL Source #
(LiteralSQL a1, LiteralSQL a2) => LiteralSQL (a1, a2) Source #
Instance details Defined in Database.Relational.TupleInstances Methods showLiteral' :: (a1, a2) -> DList StringSQL Source #
(LiteralSQL a1, LiteralSQL a2, LiteralSQL a3) => LiteralSQL (a1, a2, a3) Source #
Instance details Defined in Database.Relational.TupleInstances Methods showLiteral' :: (a1, a2, a3) -> DList StringSQL Source #
(LiteralSQL a1, LiteralSQL a2, LiteralSQL a3, LiteralSQL a4) => LiteralSQL (a1, a2, a3, a4) Source #
Instance details Defined in Database.Relational.TupleInstances Methods showLiteral' :: (a1, a2, a3, a4) -> DList StringSQL Source #
(LiteralSQL a1, LiteralSQL a2, LiteralSQL a3, LiteralSQL a4, LiteralSQL a5) => LiteralSQL (a1, a2, a3, a4, a5) Source #
Instance details Defined in Database.Relational.TupleInstances Methods showLiteral' :: (a1, a2, a3, a4, a5) -> DList StringSQL Source #
(LiteralSQL a1, LiteralSQL a2, LiteralSQL a3, LiteralSQL a4, LiteralSQL a5, LiteralSQL a6) => LiteralSQL (a1, a2, a3, a4, a5, a6) Source #
Instance details Defined in Database.Relational.TupleInstances Methods showLiteral' :: (a1, a2, a3, a4, a5, a6) -> DList StringSQL Source #
(LiteralSQL a1, LiteralSQL a2, LiteralSQL a3, LiteralSQL a4, LiteralSQL a5, LiteralSQL a6, LiteralSQL a7) => LiteralSQL (a1, a2, a3, a4, a5, a6, a7) Source #
Instance details Defined in Database.Relational.TupleInstances Methods showLiteral' :: (a1, a2, a3, a4, a5, a6, a7) -> DList StringSQL Source #

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

Convert from haskell record to SQL literal row-value.

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

Deprecated: Use showLiteral` instead of this.

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

Deprecated: Use showLiteral instead of this.

Deprecated.

class PersistableWidth ct => ScalarDegree ct Source #

Constraint which represents scalar degree.

Instances

Instances details

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

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

Type for projection function.

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

Type for predicate to restrict of query result.

data Record c t Source #

Phantom typed record. Projected into Haskell record type t.

Instances

Instances details

(PersistableWidth a, HasProjection l a b) => IsLabel l (PI c a b)	Derive `PI` label.
Instance details Defined in Database.Relational.OverloadedProjection Methods fromLabel :: PI c a b
ProductIsoFunctor (Record c) Source #	Map `Record` which result type is record.
Instance details Defined in Database.Relational.Record Methods (\|$\|) :: ProductConstructor (a -> b) => (a -> b) -> Record c a -> Record c b Source #
ProductIsoApplicative (Record c) Source #	Compose `Record` using applicative style.
Instance details Defined in Database.Relational.Record Methods pureP :: ProductConstructor a => a -> Record c a Source # (\|*\|) :: Record c (a -> b) -> Record c a -> Record c b Source #
ProjectableMaybe (Record c) Source #	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 #
ProductIsoEmpty (Record c) () Source #
Instance details Defined in Database.Relational.Record Methods pureE :: Record c () Source # peRight :: Record c (a, ()) -> Record c a Source # peLeft :: Record c ((), a) -> Record c a Source #
TableDerivable r => Show (Record Flat r -> Assign r (PlaceHolders p))	Show Set clause and WHERE clause.
Instance details Defined in Database.Relational.Effect Methods showsPrec :: Int -> (Record Flat r -> Assign r (PlaceHolders p)) -> ShowS show :: (Record Flat r -> Assign r (PlaceHolders p)) -> String showList :: [Record Flat r -> Assign r (PlaceHolders p)] -> ShowS
TableDerivable r => Show (Record Flat r -> Restrict (PlaceHolders p))	Show WHERE clause.
Instance details Defined in Database.Relational.Effect Methods showsPrec :: Int -> (Record Flat r -> Restrict (PlaceHolders p)) -> ShowS show :: (Record Flat r -> Restrict (PlaceHolders p)) -> String showList :: [Record Flat r -> Restrict (PlaceHolders p)] -> ShowS
Show (Record c t) Source #
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

data SubQuery Source #

Sub-query type

Instances

Instances details

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

data AggregateKey a Source #

Typeful aggregate element.

data Nulls Source #

Order of null.

Constructors

NullsFirst
NullsLast

Instances

Instances details

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

data Order Source #

Order direction. Ascendant or Descendant.

Constructors

Asc
Desc

Instances

Instances details

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

queryWidth :: Qualified SubQuery -> Int Source #

Width of Qualified SubQUery.

unitSQL :: SubQuery -> String Source #

SQL string for nested-qeury.

data PlaceHolders p Source #

Placeholder parameter type which has real parameter type arguemnt p.

Instances

Instances details

ProductIsoFunctor PlaceHolders Source #	Compose seed of record type `PlaceHolders`.
Instance details Defined in Database.Relational.Projectable.Instances Methods (\|$\|) :: ProductConstructor (a -> b) => (a -> b) -> PlaceHolders a -> PlaceHolders b Source #
ProductIsoApplicative PlaceHolders Source #	Compose record type `PlaceHolders` using applicative style.
Instance details Defined in Database.Relational.Projectable.Instances Methods pureP :: ProductConstructor a => a -> PlaceHolders a Source # (\|*\|) :: PlaceHolders (a -> b) -> PlaceHolders a -> PlaceHolders b Source #
ProjectableMaybe PlaceHolders Source #	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 #
ProductIsoEmpty PlaceHolders () Source #	Zipping except for identity element laws against placeholder parameter type.
Instance details Defined in Database.Relational.Projectable.Instances Methods pureE :: PlaceHolders () Source # peRight :: PlaceHolders (a, ()) -> PlaceHolders a Source # peLeft :: PlaceHolders ((), a) -> PlaceHolders a Source #
TableDerivable r => Show (Record Flat r -> Assign r (PlaceHolders p))	Show Set clause and WHERE clause.
Instance details Defined in Database.Relational.Effect Methods showsPrec :: Int -> (Record Flat r -> Assign r (PlaceHolders p)) -> ShowS show :: (Record Flat r -> Assign r (PlaceHolders p)) -> String showList :: [Record Flat r -> Assign r (PlaceHolders p)] -> ShowS
TableDerivable r => Show (Record Flat r -> Restrict (PlaceHolders p))	Show WHERE clause.
Instance details Defined in Database.Relational.Effect Methods showsPrec :: Int -> (Record Flat r -> Restrict (PlaceHolders p)) -> ShowS show :: (Record Flat r -> Restrict (PlaceHolders p)) -> String showList :: [Record Flat r -> Restrict (PlaceHolders p)] -> 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.

Instances

Instances details

SqlContext OverWindow Source #	Unsafely make `Record` from SQL terms.
Instance details Defined in Database.Relational.Projectable.Instances Methods unsafeProjectSqlTerms :: [StringSQL] -> Record OverWindow t Source #
SqlContext Aggregated Source #	Unsafely make `Record` from SQL terms.
Instance details Defined in Database.Relational.Projectable.Instances Methods unsafeProjectSqlTerms :: [StringSQL] -> Record Aggregated t Source #
SqlContext Flat Source #	Unsafely make `Record` from SQL terms.
Instance details Defined in Database.Relational.Projectable.Instances Methods unsafeProjectSqlTerms :: [StringSQL] -> Record Flat t Source #

data Relation p r Source #

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

Instances

Instances details

Show (Relation p r) Source #
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

type ConfigureQuery = Qualify (QueryConfig Identity) Source #

Thin monad type for untyped structure.

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

Run ConfigureQuery monad with initial state to get only result.

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

Get qualifyed table form query.

askConfig :: ConfigureQuery Config Source #

Read configuration.

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

Unsafely type qualified subquery into record typed relation type.

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

Sub-query Qualify monad from relation.

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

PersistableRecordWidth of Relation type.

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

Simplify placeholder type applying left identity element.

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

Simplify placeholder type applying right identity element.

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

Generate SQL string from Relation with configuration.

sqlFromRelation :: Relation p r -> StringSQL Source #

SQL string from Relation.

dump :: Relation p r -> String Source #

Dump internal structure tree.

class PersistableWidth r => TableDerivable r where Source #

Inference rule of Table existence.

Methods

derivedTable :: Table r Source #

data Table r Source #

Phantom typed table type

Instances

Instances details

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

data RecordList p t Source #

Projected record list type for row list.

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

Make projected record list from Record list.

type QuerySuffix = [Keyword] Source #

Type for query suffix words

updateOtherThanKeySQL Source #

Arguments

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

Generate update SQL specified by single key.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

tuplePi7_1' :: forall a1 a2 a3 a4 a5 a6 a7. (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_2' :: forall a1 a2 a3 a4 a5 a6 a7. (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_3' :: forall a1 a2 a3 a4 a5 a6 a7. (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_4' :: forall a1 a2 a3 a4 a5 a6 a7. (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_5' :: forall a1 a2 a3 a4 a5 a6 a7. (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_6' :: forall a1 a2 a3 a4 a5 a6 a7. (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a7 Source #

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

Projection path for fst of tuple.

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

Projection path for snd of tuple.

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 Source #	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) Source #	Not `Maybe` type is not processed.
Instance details Defined in Database.Relational.Projectable Methods flatten :: ProjectableMaybe p => p (Maybe a) -> p (Maybe a) Source #

class ProjectableMaybe p 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 Source #	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) Source #	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 #

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

Binary operator type for SQL String.

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

Unsafely Project single SQL term.

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

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

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.

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

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

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

Record with polymorphic type of SQL true value.

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

Record with polymorphic type of SQL false value.

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

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

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

Unsafely generate SQL expression term from record object.

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'.

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

Unsafely make unary operator for records from SQL keyword.

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

Unsafely make binary operator for records from string binary operator.

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

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

Logical operator corresponding SQL AND .

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

Logical operator corresponding SQL OR .

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

Logical operator corresponding SQL NOT .

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

Logical operator corresponding SQL EXISTS .

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

Concatinate operator corresponding SQL || .

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

like' :: (OperatorContext c, IsString a) => Record c a -> Record c 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, LiteralSQL a) => Record c a -> a -> Record c (Maybe Bool) infix 4 Source #

String-compare operator corresponding SQL LIKE .

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.

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

(./.) :: (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 * .

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

Number negate uni-operator corresponding SQL -.

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

Number fromIntegral uni-operator.

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

Unsafely show number into string-like type in records.

(?+?) :: (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 - .

(?/?) :: (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 * .

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

Number negate uni-operator corresponding SQL -.

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

Number fromIntegral uni-operator.

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.

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

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.

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.

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

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.

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'.

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

Binary operator corresponding SQL IN .

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

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

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

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

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.

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

RANK() term.

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

DENSE_RANK() term.

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

ROW_NUMBER() term.

percentRank :: Record OverWindow Double Source #

PERCENT_RANK() term.

cumeDist :: Record OverWindow Double Source #

CUME_DIST() term.

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

Unsafely add placeholder parameter to queries.

unsafePlaceHolders :: PlaceHolders p Source #

Unsafely get placeholder parameter

unitPlaceHolder :: PlaceHolders () Source #

No placeholder semantics

unitPH :: PlaceHolders () Source #

No placeholder semantics. Same as unitPlaceHolder

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

Provide scoped placeholder from width and return its parameter object.

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

Provide scoped placeholder and return its parameter object.

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

Zipping projections.

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

Binary operator the same as projectZip.

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

Unsafely make aggregation uni-operator from SQL keyword.

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

Aggregation function COUNT.

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

Aggregation function SUM.

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

Aggregation function SUM.

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

Aggregation function AVG.

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

Aggregation function AVG.

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

Aggregation function MAX.

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

Aggregation function MAX.

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

Aggregation function MIN.

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

Aggregation function MIN.

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

Aggregation function EVERY.

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

Aggregation function ANY.

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

Aggregation function SOME.

(!) 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.

(?!) 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 (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.

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, 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.

(?) 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
=> 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'.

class Monad m => MonadPartition c m Source #

Window specification building interface.

Minimal complete definition

partitionBy

Instances

Instances details

MonadPartition c m => MonadPartition c (Orderings c m) Source #	`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) Source #	Partition clause instance
Instance details Defined in Database.Relational.Monad.Trans.Aggregating Methods partitionBy :: Record c r -> PartitioningSetT c m () Source #

class MonadQuery m => MonadAggregate m Source #

Aggregated query building interface extends MonadQuery.

Minimal complete definition

groupBy, groupBy'

Instances

Instances details

MonadQuery m => MonadAggregate (AggregatingSetT m) Source #	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 (Restrictings c m) Source #	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 #
MonadAggregate m => MonadAggregate (Orderings c m) Source #	`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 #

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

Lift interface from base qualify monad.

Minimal complete definition

liftQualify

Instances

Instances details

(Functor q, Monad q) => MonadQualify q q Source #
Instance details Defined in Database.Relational.Monad.Class Methods liftQualify :: q a -> q a Source #
MonadQualify ConfigureQuery QueryUnique Source #
Instance details Defined in Database.Relational.Monad.Unique Methods liftQualify :: ConfigureQuery a -> QueryUnique a Source #
MonadQualify q m => MonadQualify q (QueryJoin m) Source #
Instance details Defined in Database.Relational.Monad.Trans.Join Methods liftQualify :: q a -> QueryJoin m a Source #
MonadQualify q m => MonadQualify q (AggregatingSetT m) Source #	Aggregated `MonadQualify`.
Instance details Defined in Database.Relational.Monad.Trans.Aggregating Methods liftQualify :: q a -> AggregatingSetT m a Source #
MonadQualify q m => MonadQualify q (Restrictings c m) Source #	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 (Orderings c m) Source #	`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 (Assignings r m) Source #	`MonadQualify` with assigning.
Instance details Defined in Database.Relational.Monad.Trans.Assigning Methods liftQualify :: q a -> Assignings r m a Source #

class (Functor m, Monad m, MonadQualify ConfigureQuery m) => MonadQuery m Source #

Query building interface.

Minimal complete definition

setDuplication, restrictJoin, query', queryMaybe'

Instances

Instances details

MonadQuery QueryUnique Source #
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 (QueryJoin ConfigureQuery) Source #	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 (AggregatingSetT m) Source #	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 q => MonadQuery (Restrictings c q) Source #	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 #
MonadQuery m => MonadQuery (Orderings c m) Source #	`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 #

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

type Restrict = Restrictings Flat ConfigureQuery Source #

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

type OrderedQuery c m 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.

type QueryCore = Restrictings Flat (QueryJoin ConfigureQuery) Source #

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

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

Extract QueryCore computation.

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

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

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

Add an assignment.

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

Add and assginment.

type Assign r = Assignings r Restrict Source #

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

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).

data UniqueRelation p c r Source #

Unique relation type to compose scalar queries.

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

Simple Relation from Table.

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

Inferred Relation.

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

Interface to derive Table type object.

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

Unsafely specify unique relation.

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

Discard unique attribute.

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

Aggregated UniqueRelation.

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

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.

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.

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.

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.

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.

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.

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.

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.

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

Apply restriction for direct join style.

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

Union of two relations.

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

Union of two relations. Not distinct.

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

Subtraction of two relations.

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

Subtraction of two relations. Not distinct.

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

Intersection of two relations.

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

Intersection of two relations. Not distinct.

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

Union 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.

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

Subtraction 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.

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

Intersection of two relations with place-holder parameters.

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

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

data InsertTarget p r Source #

InsertTarget 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.

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

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

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

Deprecated: same as ((>> return unitPH) .)

Deprecated.

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

Deprecated: same as id

Deprecated.

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

Deprecated: low-level API, this API will be expired.

SQL WHERE clause StringSQL string from Restrict computation.

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

Deprecated: old-style API. Use new-style Database.Relational.updateNoPH.

Deprecated.

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

Deprecated: same as id

Deprecated.

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

Deprecated: old-style API. use Database.Relational.updateAllColumnNoPH instead of this.

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

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.

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

Deprecated: Use Database.Relational.updateAllColumnNoPH instead of this.

Deprecated.

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

Deprecated: Use Database.Relational.updateAllColumn instead of this.

Deprecated.

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

Deprecated: low-level API, this API will be expired.

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

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

Deprecated: old-style API. Use new-style Database.Relational.insertValueNoPH .

Finalize Register monad and generate InsertTarget.

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

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

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

parametalized Register monad from Pi

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

Make StringSQL string of SQL INSERT record chunk statement from InsertTarget

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

Make StringSQL string of SQL INSERT statement from InsertTarget

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

Make StringSQL strings of SQL INSERT strings from records list

class UntypeableNoFetch s 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 Delete Source #
Instance details Defined in Database.Relational.Type Methods untypeNoFetch :: Delete p -> String Source #
UntypeableNoFetch InsertQuery Source #
Instance details Defined in Database.Relational.Type Methods untypeNoFetch :: InsertQuery p -> String Source #
UntypeableNoFetch Insert Source #
Instance details Defined in Database.Relational.Type Methods untypeNoFetch :: Insert p -> String Source #
UntypeableNoFetch Update Source #
Instance details Defined in Database.Relational.Type Methods untypeNoFetch :: Update p -> String Source #

newtype Delete p Source #

Delete type with place-holder parameter p.

Constructors

Delete
Fields untypeDelete :: String

Instances

Instances details

UntypeableNoFetch Delete Source #
Instance details Defined in Database.Relational.Type Methods untypeNoFetch :: Delete p -> String Source #
Show (Delete p) Source #	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

newtype InsertQuery p Source #

InsertQuery type.

Constructors

InsertQuery
Fields untypeInsertQuery :: String

Instances

Instances details

UntypeableNoFetch InsertQuery Source #
Instance details Defined in Database.Relational.Type Methods untypeNoFetch :: InsertQuery p -> String Source #
Show (InsertQuery p) Source #	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

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 Source #
Instance details Defined in Database.Relational.Type Methods untypeNoFetch :: Insert p -> String Source #
Show (Insert a) Source #	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 Update p Source #

Update type with place-holder parameter p.

Constructors

Update
Fields untypeUpdate :: String

Instances

Instances details

UntypeableNoFetch Update Source #
Instance details Defined in Database.Relational.Type Methods untypeNoFetch :: Update p -> String Source #
Show (Update p) Source #	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 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) Source #	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 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) Source #	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

unsafeTypedQuery Source #

Arguments

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

Unsafely make typed Query from SQL string.

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

From Relation into untyped SQL query string.

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

From Relation into typed Query with suffix SQL words.

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

From Relation into typed Query with suffix SQL words.

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

From Relation into typed Query.

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

Make typed KeyUpdate from 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.

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

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

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

Deprecated: use keyUpdate instead of this.

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

unsafeTypedUpdate :: String -> Update p Source #

Unsafely make typed Update from SQL string.

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

Make untyped update SQL string from 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.

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

Deprecated: use typedUpdate defaultConfig` instead of this.

Make typed Update using defaultConfig, Table and Assign computation.

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.

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

Deprecated: use updateAllColumn` instead of this.

Deprecated. use updateAllColumn'.

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

Deprecated: use updateAllColumn instead of this.

Deprecated. use updateAllColumn.

untypeChunkInsert :: Insert a -> String Source #

Statement to use chunked insert

chunkSizeOfInsert :: Insert a -> Int Source #

Size to use chunked insert

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

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

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

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

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

Deprecated: use typedInsert defaultConfig` instead of this.

Make typed Insert from Table and columns selector Pi.

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

Table type inferred Insert.

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

Deprecated: use insert instead of this.

Table type inferred Insert.

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

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

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

Deprecated: use typedInsertValue defaultConfig` instead of this.

Make typed Insert from Table and monadic builded InsertTarget object.

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

Make typed Insert list from Config and records list.

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

Make typed Insert list from records list.

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

Make untyped insert select SQL string from 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.

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

Deprecated: use typedInsertQuery defaultConfig` instead of this.

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

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

Table type inferred InsertQuery.

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

Table type inferred InsertQuery with defaultConfig.

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

Deprecated: use insertQuery instead of this.

Table type inferred InsertQuery.

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

Make untyped delete SQL string 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.

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

Deprecated: use typedDelete defaultConfig` instead of this.

Make typed Delete from Table and Restrict computation.

data Number r i Source #

Sequence number type for record type r

Instances

Instances details

Eq i => Eq (Number r i) Source #
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) Source #
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) Source #
Instance details Defined in Database.Relational.Sequence Methods showsPrec :: Int -> Number r i -> ShowS show :: Number r i -> String showList :: [Number r i] -> ShowS

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 #

default binding :: HasConstraintKey Primary r i => SeqBinding r s i Source #

data SeqBinding r s i Source #

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

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

Sequence derivation rule

Methods

derivedSequence :: Sequence s i Source #

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.

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

Unsafely specify sequence table.

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

Infer Relation of sequence table

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

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

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

Derive binding using primary key.

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

Derive Sequence from corresponding Relation

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

Unsafely specify sequence number.

extractNumber :: Number r i -> i Source #

Get untyped sequence number.

($$!) Source #

Arguments

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

Unsafely apply sequence number.

($$) 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.

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

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

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.

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.

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

Deprecated: use uniqueSelect instead of this.

Deprecated.

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: use primarySelect instead of this.

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 :: HasConstraintKey Primary a p => Relation () a -> Relation p a Source #

Deprecated: use primarySelect instead of this.

Deprecated.

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.

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.

primaryUpdate Source #

Arguments

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

Typed KeyUpdate using inferred primary key.

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.

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

Same as all'. Arrow version.

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

Same as distinct. Arrow version.

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

Same as query. Arrow version. The result arrow is not injected by local projected records.

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

Same as queryMaybe. Arrow version. The result arrow is not injected by any local projected records.

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

Same as query'. Arrow version. The result arrow is not injected by any local projected records.

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

Same as queryMaybe'. Arrow version. The result arrow is not injected by any local projected records.

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

Same as queryList. Arrow version. The result arrow is designed to be injected by local projected records.

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

Same as queryList'. Arrow version. The result arrow is designed to be injected by local projected records.

queryExists :: MonadQualify ConfigureQuery m => (Record c a -> Relation () r) -> QueryA m (Record c a) (RecordList (Record Exists) r) Source #

Same as queryList to pass this result to exists operator. Arrow version. The result arrow is designed to be injected by local projected records.

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

Same as queryList' to pass this result to exists operator. Arrow version. The result arrow is designed to be injected by local projected records.

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

Same as queryList. Arrow version. Useful for no reference cases to local projected records.

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

Same as queryList'. Arrow version. Useful for no reference cases to local projected records.

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

Same as queryScalar. Arrow version. The result arrow is designed to be injected by any local projected record.

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

Same as queryScalar'. Arrow version. The result arrow is designed to be injected by any local projected record.

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

Same as queryScalar. Arrow version. Useful for no reference cases to local projected records.

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

Same as queryScalar'. Arrow version. Useful for no reference cases to local projected records.

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

Same as uniqueQuery'. Arrow version. The result arrow is not injected by local projected records.

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

Same as uniqueQueryMaybe'. Arrow version. The result arrow is not injected by local projected records.

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

Same as on. Arrow version. The result arrow is designed to be injected by local conditional flat-records.

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

Same as wheres. Arrow version. The result arrow is designed to be injected by local conditional flat-records.

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

Same as having. Arrow version. The result arrow is designed to be injected by local conditional aggregated-records.

groupBy :: MonadAggregate m => QueryA m (Record Flat r) (Record Aggregated r) Source #

Same as groupBy. Arrow version. The result arrow is designed to be injected by local flat-records.

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

Same as placeholder. Arrow version. The result arrow is designed to be injected by locally built arrow using placeholders.

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

Same as relation. Finalize query-building arrow instead of query-building monad.

relation' :: QuerySimple () (PlaceHolders p, Record Flat r) -> Relation p r Source #

Same as relation'. Finalize query-building arrow instead of query-building monad.

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

Same as aggregateRelation. Finalize query-building arrow instead of query-building monad.

aggregateRelation' :: QueryAggregate () (PlaceHolders p, Record Aggregated r) -> Relation p r Source #

Same as aggregateRelation'. Finalize query-building arrow instead of query-building monad.

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

Same as uniqueRelation'. Finalize query-building arrow instead of query-building monad.

groupBy' :: MonadAggregate m => QueryA m (AggregateKey (Record Aggregated r)) (Record Aggregated r) Source #

Same as groupBy'. This arrow is designed to be injected by local AggregateKey.

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

Same as key. This arrow is designed to be injected by local flat-records.

key' :: AggregatingSet (AggregateKey a) a Source #

Same as key'. This arrow is designed to be injected by local AggregteKey.

set :: AggregatingSetList (AggregatingSet () a) a Source #

Same as set. This arrow is designed to be injected by locally built AggregtingSet arrow.

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

Same as bkey. This arrow is designed to be injected by local flat-records.

rollup :: AggregatingPowerSet () a -> AggregateKey a Source #

Same as rollup. Finalize locally built AggregatingPowerSet.

cube :: AggregatingPowerSet () a -> AggregateKey a Source #

Same as cube. Finalize locally built AggregatingPowerSet.

groupingSets :: AggregatingSetList () a -> AggregateKey a Source #

Same as groupingSets. Finalize locally built AggregatingSetList.

orderBy' :: Monad m => Order -> Nulls -> Orderings c m (Record c t) () Source #

Same as orderBy'. The result arrow is designed to be injected by local projected records.

orderBy :: Monad m => Order -> Orderings c m (Record c t) () Source #

Same as orderBy. The result arrow is designed to be injected by local projected records.

asc :: Monad m => Orderings c m (Record c t) () Source #

Same as asc. The result arrow is designed to be injected by local projected records.

desc :: Monad m => Orderings c m (Record c t) () Source #

Same as desc. The result arrow is designed to be injected by local projected records.

partitionBy :: Window c (Record c r) () Source #

Same as partitionBy. The result arrow is designed to be injected by local projected records.

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

Same as over. Make record of window function result using built Window arrow.

assign :: Monad m => AssignTarget r v -> Assignings r m (Record Flat v) () Source #

Make AssignTarget into arrow which is designed to be injected by assignees of local projected record.

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

Same as update'. Make Update from assigning statement arrow using configuration.

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

Same as update. Make Update from assigning statement arrow.

updateNoPH :: TableDerivable r => QueryA (Assignings r Restrict) (Record Flat r) () -> Update () Source #

Same as updateNoPH. Make Update from assigning statement arrow.

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

Same as updateAllColumn'. Make Update from restrected statement arrow.

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

Same as updateAllColumn. Make Update from restrected statement arrow.

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

Same as updateAllColumnNoPH. Make Update from restrected statement arrow.

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

Same as insertValue'. Make Insert from register arrow using configuration.

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

Same as insertValue. Make Insert from register arrow.

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

Same as insertValueNoPH. Make Insert from register arrow.

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

Same as delete'. Make Update from restrict statement arrow using configuration.

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

Same as delete. Make Update from restrict statement arrow.

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

Same as deleteNoPH. Make Update from restrict statement arrow.

data QueryA m a b Source #

Arrow to build queries.

Instances

Instances details

Monad m => Arrow (QueryA m) Source #
Instance details Defined in Database.Relational.Arrow Methods arr :: (b -> c) -> QueryA m b c first :: QueryA m b c -> QueryA m (b, d) (c, d) second :: QueryA m b c -> QueryA m (d, b) (d, c) (***) :: QueryA m b c -> QueryA m b' c' -> QueryA m (b, b') (c, c') (&&&) :: QueryA m b c -> QueryA m b c' -> QueryA m b (c, c')
Monad m => Category (QueryA m :: Type -> Type -> Type) Source #
Instance details Defined in Database.Relational.Arrow Methods id :: forall (a :: k). QueryA m a a (.) :: forall (b :: k) (c :: k) (a :: k). QueryA m b c -> QueryA m a b -> QueryA m a c