packages feed

relational-query 0.12.0.0 → 0.12.0.1

raw patch · 2 files changed

+11/−1 lines, 2 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

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

Files

ChangeLog.md view
@@ -1,5 +1,15 @@ <!-- -*- Markdown -*- --> +## 0.12.0.1++- Update missing of this changelog.++## 0.12.0.0++- rename from ShowConstantTermsSQL to LiteralSQL.+- drop #tuplePiM_N.+- drop old compat modules for relational-query-0.9.x.+ ## 0.11.4.0  - add xxxNoPH effect APIs of arrow-interface.
relational-query.cabal view
@@ -1,5 +1,5 @@ name:                relational-query-version:             0.12.0.0+version:             0.12.0.1 synopsis:            Typeful, Modular, Relational, algebraic query engine description:         This package contiains typeful relation structure and                      relational-algebraic query building DSL which can