relational-query 0.6.0.0 → 0.6.1.0

raw patch · 3 files changed

+16/−9 lines, 3 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- Database.Relational.Query.Arrow: instance Monad m => Arrow (QueryA m)

- Database.Relational.Query.Arrow: instance Monad m => Category (QueryA m)

- Database.Relational.Query.Component: instance Functor ColumnSQL'

- Database.Relational.Query.Component: instance Show AggregateBitKey

- Database.Relational.Query.Component: instance Show AggregateElem

- Database.Relational.Query.Component: instance Show AggregateSet

- Database.Relational.Query.Component: instance Show ColumnSQL

- Database.Relational.Query.Component: instance Show Config

- Database.Relational.Query.Component: instance Show Duplication

- Database.Relational.Query.Component: instance Show Order

- Database.Relational.Query.Component: instance Show ProductUnitSupport

- Database.Relational.Query.Effect: instance TableDerivable r => Show (Restriction p r)

- Database.Relational.Query.Effect: instance TableDerivable r => Show (UpdateTarget p r)

- Database.Relational.Query.Expr.Unsafe: instance Show (Expr p a)

- Database.Relational.Query.Monad.Aggregate: instance MonadRestrict Flat q => MonadRestrict Flat (Restrictings Aggregated q)

- Database.Relational.Query.Monad.BaseType: instance Show (Relation p r)

- Database.Relational.Query.Monad.Class: instance (Functor q, Monad q) => MonadQualify q q

- Database.Relational.Query.Monad.Restrict: instance MonadQualify ConfigureQuery Restrict

- Database.Relational.Query.Monad.Trans.Aggregating: instance Applicative m => Applicative (Aggregatings ac at m)

- Database.Relational.Query.Monad.Trans.Aggregating: instance Functor m => Functor (Aggregatings ac at m)

- Database.Relational.Query.Monad.Trans.Aggregating: instance Monad m => Monad (Aggregatings ac at m)

- Database.Relational.Query.Monad.Trans.Aggregating: instance Monad m => MonadPartition c (PartitioningSetT c m)

- Database.Relational.Query.Monad.Trans.Aggregating: instance MonadQualify q m => MonadQualify q (AggregatingSetT m)

- Database.Relational.Query.Monad.Trans.Aggregating: instance MonadQuery m => MonadAggregate (AggregatingSetT m)

- Database.Relational.Query.Monad.Trans.Aggregating: instance MonadQuery m => MonadQuery (AggregatingSetT m)

- Database.Relational.Query.Monad.Trans.Aggregating: instance MonadRestrict c m => MonadRestrict c (AggregatingSetT m)

- Database.Relational.Query.Monad.Trans.Aggregating: instance MonadTrans (Aggregatings ac at)

- Database.Relational.Query.Monad.Trans.Assigning: instance Applicative m => Applicative (Assignings r m)

- Database.Relational.Query.Monad.Trans.Assigning: instance Functor m => Functor (Assignings r m)

- Database.Relational.Query.Monad.Trans.Assigning: instance Monad m => Monad (Assignings r m)

- Database.Relational.Query.Monad.Trans.Assigning: instance MonadRestrict c m => MonadRestrict c (Assignings r m)

- Database.Relational.Query.Monad.Trans.Assigning: instance MonadTrans (Assignings r)

- Database.Relational.Query.Monad.Trans.Config: instance Applicative m => Applicative (QueryConfig m)

- Database.Relational.Query.Monad.Trans.Config: instance Functor m => Functor (QueryConfig m)

- Database.Relational.Query.Monad.Trans.Config: instance Monad m => Monad (QueryConfig m)

- Database.Relational.Query.Monad.Trans.Join: instance (Monad m, Functor m) => Applicative (QueryJoin m)

- Database.Relational.Query.Monad.Trans.Join: instance Functor m => Functor (QueryJoin m)

- Database.Relational.Query.Monad.Trans.Join: instance Monad m => Monad (QueryJoin m)

- Database.Relational.Query.Monad.Trans.Join: instance MonadQualify q m => MonadQualify q (QueryJoin m)

- Database.Relational.Query.Monad.Trans.Join: instance MonadQuery (QueryJoin ConfigureQuery)

- Database.Relational.Query.Monad.Trans.Join: instance MonadTrans QueryJoin

- Database.Relational.Query.Monad.Trans.Ordering: instance Applicative m => Applicative (Orderings c m)

- Database.Relational.Query.Monad.Trans.Ordering: instance Functor m => Functor (Orderings c m)

- Database.Relational.Query.Monad.Trans.Ordering: instance Monad m => Monad (Orderings c m)

- Database.Relational.Query.Monad.Trans.Ordering: instance MonadAggregate m => MonadAggregate (Orderings c m)

- Database.Relational.Query.Monad.Trans.Ordering: instance MonadPartition c m => MonadPartition c (Orderings c m)

- Database.Relational.Query.Monad.Trans.Ordering: instance MonadQualify q m => MonadQualify q (Orderings c m)

- Database.Relational.Query.Monad.Trans.Ordering: instance MonadQuery m => MonadQuery (Orderings c m)

- Database.Relational.Query.Monad.Trans.Ordering: instance MonadRestrict rc m => MonadRestrict rc (Orderings c m)

- Database.Relational.Query.Monad.Trans.Ordering: instance MonadTrans (Orderings c)

- Database.Relational.Query.Monad.Trans.Ordering: instance ProjectableOrdering (Projection c)

- Database.Relational.Query.Monad.Trans.Restricting: instance (Monad q, Functor q) => MonadRestrict c (Restrictings c q)

- Database.Relational.Query.Monad.Trans.Restricting: instance Applicative m => Applicative (Restrictings c m)

- Database.Relational.Query.Monad.Trans.Restricting: instance Functor m => Functor (Restrictings c m)

- Database.Relational.Query.Monad.Trans.Restricting: instance Monad m => Monad (Restrictings c m)

- Database.Relational.Query.Monad.Trans.Restricting: instance MonadAggregate m => MonadAggregate (Restrictings c m)

- Database.Relational.Query.Monad.Trans.Restricting: instance MonadQualify q m => MonadQualify q (Restrictings c m)

- Database.Relational.Query.Monad.Trans.Restricting: instance MonadQuery q => MonadQuery (Restrictings c q)

- Database.Relational.Query.Monad.Trans.Restricting: instance MonadTrans (Restrictings c)

- Database.Relational.Query.Monad.Unique: instance Applicative QueryUnique

- Database.Relational.Query.Monad.Unique: instance Functor QueryUnique

- Database.Relational.Query.Monad.Unique: instance Monad QueryUnique

- Database.Relational.Query.Monad.Unique: instance MonadQualify ConfigureQuery QueryUnique

- Database.Relational.Query.Monad.Unique: instance MonadQuery QueryUnique

- Database.Relational.Query.Projectable: instance OperatorProjectable (Expr Aggregated)

- Database.Relational.Query.Projectable: instance OperatorProjectable (Expr Flat)

- Database.Relational.Query.Projectable: instance OperatorProjectable (Projection Aggregated)

- Database.Relational.Query.Projectable: instance OperatorProjectable (Projection Flat)

- Database.Relational.Query.Projectable: instance ProjectableApplicative (Pi a)

- Database.Relational.Query.Projectable: instance ProjectableApplicative (Projection c)

- Database.Relational.Query.Projectable: instance ProjectableApplicative PlaceHolders

- Database.Relational.Query.Projectable: instance ProjectableFunctor (Pi a)

- Database.Relational.Query.Projectable: instance ProjectableFunctor (Projection c)

- Database.Relational.Query.Projectable: instance ProjectableFunctor PlaceHolders

- Database.Relational.Query.Projectable: instance ProjectableIdZip PlaceHolders

- Database.Relational.Query.Projectable: instance ProjectableMaybe (Expr p)

- Database.Relational.Query.Projectable: instance ProjectableMaybe (Projection c)

- Database.Relational.Query.Projectable: instance ProjectableMaybe PlaceHolders

- Database.Relational.Query.Projectable: instance ProjectableShowSql (Expr p)

- Database.Relational.Query.Projectable: instance ProjectableShowSql (Projection c)

- Database.Relational.Query.Projectable: instance SqlProjectable (Expr p)

- Database.Relational.Query.Projectable: instance SqlProjectable (Projection Aggregated)

- Database.Relational.Query.Projectable: instance SqlProjectable (Projection Flat)

- Database.Relational.Query.Projectable: instance SqlProjectable (Projection OverWindow)

- Database.Relational.Query.ProjectableExtended: instance AggregatedContext Aggregated

- Database.Relational.Query.ProjectableExtended: instance AggregatedContext OverWindow

- Database.Relational.Query.ProjectableExtended: instance Projectable Projection Expr

- Database.Relational.Query.ProjectableExtended: instance Projectable Projection Projection

- Database.Relational.Query.ProjectableExtended: instance ProjectableFlattenMaybe (Maybe a) (Maybe a)

- Database.Relational.Query.ProjectableExtended: instance ProjectableFlattenMaybe (Maybe a) b => ProjectableFlattenMaybe (Maybe (Maybe a)) b

- Database.Relational.Query.ProjectableExtended: instance ProjectableRunIdsZip a a

- Database.Relational.Query.ProjectableExtended: instance ProjectableRunIdsZip a b => ProjectableRunIdsZip ((), a) b

- Database.Relational.Query.ProjectableExtended: instance ProjectableRunIdsZip a b => ProjectableRunIdsZip (a, ()) b

- Database.Relational.Query.Pure: instance (PersistableWidth a, ShowConstantTermsSQL a) => ShowConstantTermsSQL (Maybe a)

- Database.Relational.Query.Pure: instance (ShowConstantTermsSQL a, ShowConstantTermsSQL b) => ShowConstantTermsSQL (a, b)

- Database.Relational.Query.Pure: instance ProductConstructor (a -> b -> (a, b))

- Database.Relational.Query.Pure: instance ShowConstantTermsSQL Bool

- Database.Relational.Query.Pure: instance ShowConstantTermsSQL ByteString

- Database.Relational.Query.Pure: instance ShowConstantTermsSQL Char

- Database.Relational.Query.Pure: instance ShowConstantTermsSQL Day

- Database.Relational.Query.Pure: instance ShowConstantTermsSQL Double

- Database.Relational.Query.Pure: instance ShowConstantTermsSQL Float

- Database.Relational.Query.Pure: instance ShowConstantTermsSQL Int

- Database.Relational.Query.Pure: instance ShowConstantTermsSQL Int16

- Database.Relational.Query.Pure: instance ShowConstantTermsSQL Int32

- Database.Relational.Query.Pure: instance ShowConstantTermsSQL Int64

- Database.Relational.Query.Pure: instance ShowConstantTermsSQL LocalTime

- Database.Relational.Query.Pure: instance ShowConstantTermsSQL String

- Database.Relational.Query.Pure: instance ShowConstantTermsSQL Text

- Database.Relational.Query.Pure: instance ShowConstantTermsSQL TimeOfDay

- Database.Relational.Query.Scalar: instance ScalarDegree ct => ScalarDegree (Maybe ct)

- Database.Relational.Query.Sub: instance Functor Qualified

- Database.Relational.Query.Sub: instance Show BinOp

- Database.Relational.Query.Sub: instance Show ProjectionUnit

- Database.Relational.Query.Sub: instance Show Qualifier

- Database.Relational.Query.Sub: instance Show SetOp

- Database.Relational.Query.Sub: instance Show SubQuery

- Database.Relational.Query.Sub: instance Show a => Show (Qualified a)

- Database.Relational.Query.Table: instance Show Untyped

- Database.Relational.Query.Type: chunkSizeOfInsert :: Insert a -> Int

- Database.Relational.Query.Type: instance Show (Delete p)

- Database.Relational.Query.Type: instance Show (Insert a)

- Database.Relational.Query.Type: instance Show (InsertQuery p)

- Database.Relational.Query.Type: instance Show (KeyUpdate p a)

- Database.Relational.Query.Type: instance Show (Query p a)

- Database.Relational.Query.Type: instance Show (Update p)

- Database.Relational.Query.Type: instance UntypeableNoFetch Delete

- Database.Relational.Query.Type: instance UntypeableNoFetch Insert

- Database.Relational.Query.Type: instance UntypeableNoFetch Update

- Database.Relational.Query.Type: untypeChunkInsert :: Insert a -> String

- Database.Relational.Query.Type: untypeDelete :: Delete p -> String

- Database.Relational.Query.Type: untypeInsert :: Insert a -> String

- Database.Relational.Query.Type: untypeInsertQuery :: InsertQuery p -> String

- Database.Relational.Query.Type: untypeKeyUpdate :: KeyUpdate p a -> String

- Database.Relational.Query.Type: untypeQuery :: Query p a -> String

- Database.Relational.Query.Type: untypeUpdate :: Update p -> String

- Database.Relational.Query.Type: updateKey :: KeyUpdate p a -> Pi a p

+ Database.Relational.Query.Arrow: instance GHC.Base.Monad m => Control.Arrow.Arrow (Database.Relational.Query.Arrow.QueryA m)

+ Database.Relational.Query.Arrow: instance GHC.Base.Monad m => Control.Category.Category (Database.Relational.Query.Arrow.QueryA m)

+ Database.Relational.Query.Component: instance GHC.Base.Functor Database.Relational.Query.Component.ColumnSQL'

+ Database.Relational.Query.Component: instance GHC.Show.Show Database.Relational.Query.Component.AggregateBitKey

+ Database.Relational.Query.Component: instance GHC.Show.Show Database.Relational.Query.Component.AggregateElem

+ Database.Relational.Query.Component: instance GHC.Show.Show Database.Relational.Query.Component.AggregateSet

+ Database.Relational.Query.Component: instance GHC.Show.Show Database.Relational.Query.Component.ColumnSQL

+ Database.Relational.Query.Component: instance GHC.Show.Show Database.Relational.Query.Component.Config

+ Database.Relational.Query.Component: instance GHC.Show.Show Database.Relational.Query.Component.Duplication

+ Database.Relational.Query.Component: instance GHC.Show.Show Database.Relational.Query.Component.Order

+ Database.Relational.Query.Component: instance GHC.Show.Show Database.Relational.Query.Component.ProductUnitSupport

+ Database.Relational.Query.Effect: instance Database.Relational.Query.Table.TableDerivable r => GHC.Show.Show (Database.Relational.Query.Effect.Restriction p r)

+ Database.Relational.Query.Effect: instance Database.Relational.Query.Table.TableDerivable r => GHC.Show.Show (Database.Relational.Query.Effect.UpdateTarget p r)

+ Database.Relational.Query.Expr.Unsafe: instance GHC.Show.Show (Database.Relational.Query.Expr.Unsafe.Expr p a)

+ Database.Relational.Query.Monad.Aggregate: instance Database.Relational.Query.Monad.Class.MonadRestrict Database.Relational.Query.Context.Flat q => Database.Relational.Query.Monad.Class.MonadRestrict Database.Relational.Query.Context.Flat (Database.Relational.Query.Monad.Trans.Restricting.Restrictings Database.Relational.Query.Context.Aggregated q)

+ Database.Relational.Query.Monad.BaseType: instance GHC.Show.Show (Database.Relational.Query.Monad.BaseType.Relation p r)

+ Database.Relational.Query.Monad.Class: instance (GHC.Base.Functor q, GHC.Base.Monad q) => Database.Relational.Query.Monad.Class.MonadQualify q q

+ Database.Relational.Query.Monad.Restrict: instance Database.Relational.Query.Monad.Class.MonadQualify Database.Relational.Query.Monad.BaseType.ConfigureQuery Database.Relational.Query.Monad.Restrict.Restrict

+ Database.Relational.Query.Monad.Trans.Aggregating: instance Control.Monad.Trans.Class.MonadTrans (Database.Relational.Query.Monad.Trans.Aggregating.Aggregatings ac at)

+ Database.Relational.Query.Monad.Trans.Aggregating: instance Database.Relational.Query.Monad.Class.MonadQualify q m => Database.Relational.Query.Monad.Class.MonadQualify q (Database.Relational.Query.Monad.Trans.Aggregating.AggregatingSetT m)

+ Database.Relational.Query.Monad.Trans.Aggregating: instance Database.Relational.Query.Monad.Class.MonadQuery m => Database.Relational.Query.Monad.Class.MonadAggregate (Database.Relational.Query.Monad.Trans.Aggregating.AggregatingSetT m)

+ Database.Relational.Query.Monad.Trans.Aggregating: instance Database.Relational.Query.Monad.Class.MonadQuery m => Database.Relational.Query.Monad.Class.MonadQuery (Database.Relational.Query.Monad.Trans.Aggregating.AggregatingSetT m)

+ Database.Relational.Query.Monad.Trans.Aggregating: instance Database.Relational.Query.Monad.Class.MonadRestrict c m => Database.Relational.Query.Monad.Class.MonadRestrict c (Database.Relational.Query.Monad.Trans.Aggregating.AggregatingSetT m)

+ Database.Relational.Query.Monad.Trans.Aggregating: instance GHC.Base.Applicative m => GHC.Base.Applicative (Database.Relational.Query.Monad.Trans.Aggregating.Aggregatings ac at m)

+ Database.Relational.Query.Monad.Trans.Aggregating: instance GHC.Base.Functor m => GHC.Base.Functor (Database.Relational.Query.Monad.Trans.Aggregating.Aggregatings ac at m)

+ Database.Relational.Query.Monad.Trans.Aggregating: instance GHC.Base.Monad m => Database.Relational.Query.Monad.Class.MonadPartition c (Database.Relational.Query.Monad.Trans.Aggregating.PartitioningSetT c m)

+ Database.Relational.Query.Monad.Trans.Aggregating: instance GHC.Base.Monad m => GHC.Base.Monad (Database.Relational.Query.Monad.Trans.Aggregating.Aggregatings ac at m)

+ Database.Relational.Query.Monad.Trans.Assigning: instance Control.Monad.Trans.Class.MonadTrans (Database.Relational.Query.Monad.Trans.Assigning.Assignings r)

+ Database.Relational.Query.Monad.Trans.Assigning: instance Database.Relational.Query.Monad.Class.MonadRestrict c m => Database.Relational.Query.Monad.Class.MonadRestrict c (Database.Relational.Query.Monad.Trans.Assigning.Assignings r m)

+ Database.Relational.Query.Monad.Trans.Assigning: instance GHC.Base.Applicative m => GHC.Base.Applicative (Database.Relational.Query.Monad.Trans.Assigning.Assignings r m)

+ Database.Relational.Query.Monad.Trans.Assigning: instance GHC.Base.Functor m => GHC.Base.Functor (Database.Relational.Query.Monad.Trans.Assigning.Assignings r m)

+ Database.Relational.Query.Monad.Trans.Assigning: instance GHC.Base.Monad m => GHC.Base.Monad (Database.Relational.Query.Monad.Trans.Assigning.Assignings r m)

+ Database.Relational.Query.Monad.Trans.Config: instance GHC.Base.Applicative m => GHC.Base.Applicative (Database.Relational.Query.Monad.Trans.Config.QueryConfig m)

+ Database.Relational.Query.Monad.Trans.Config: instance GHC.Base.Functor m => GHC.Base.Functor (Database.Relational.Query.Monad.Trans.Config.QueryConfig m)

+ Database.Relational.Query.Monad.Trans.Config: instance GHC.Base.Monad m => GHC.Base.Monad (Database.Relational.Query.Monad.Trans.Config.QueryConfig m)

+ Database.Relational.Query.Monad.Trans.Join: instance Control.Monad.Trans.Class.MonadTrans Database.Relational.Query.Monad.Trans.Join.QueryJoin

+ Database.Relational.Query.Monad.Trans.Join: instance Database.Relational.Query.Monad.Class.MonadQualify q m => Database.Relational.Query.Monad.Class.MonadQualify q (Database.Relational.Query.Monad.Trans.Join.QueryJoin m)

+ Database.Relational.Query.Monad.Trans.Join: instance Database.Relational.Query.Monad.Class.MonadQuery (Database.Relational.Query.Monad.Trans.Join.QueryJoin Database.Relational.Query.Monad.BaseType.ConfigureQuery)

+ Database.Relational.Query.Monad.Trans.Join: instance GHC.Base.Functor m => GHC.Base.Functor (Database.Relational.Query.Monad.Trans.Join.QueryJoin m)

+ Database.Relational.Query.Monad.Trans.Join: instance GHC.Base.Monad m => GHC.Base.Applicative (Database.Relational.Query.Monad.Trans.Join.QueryJoin m)

+ Database.Relational.Query.Monad.Trans.Join: instance GHC.Base.Monad m => GHC.Base.Monad (Database.Relational.Query.Monad.Trans.Join.QueryJoin m)

+ Database.Relational.Query.Monad.Trans.Ordering: instance Control.Monad.Trans.Class.MonadTrans (Database.Relational.Query.Monad.Trans.Ordering.Orderings c)

+ Database.Relational.Query.Monad.Trans.Ordering: instance Database.Relational.Query.Monad.Class.MonadAggregate m => Database.Relational.Query.Monad.Class.MonadAggregate (Database.Relational.Query.Monad.Trans.Ordering.Orderings c m)

+ Database.Relational.Query.Monad.Trans.Ordering: instance Database.Relational.Query.Monad.Class.MonadPartition c m => Database.Relational.Query.Monad.Class.MonadPartition c (Database.Relational.Query.Monad.Trans.Ordering.Orderings c m)

+ Database.Relational.Query.Monad.Trans.Ordering: instance Database.Relational.Query.Monad.Class.MonadQualify q m => Database.Relational.Query.Monad.Class.MonadQualify q (Database.Relational.Query.Monad.Trans.Ordering.Orderings c m)

+ Database.Relational.Query.Monad.Trans.Ordering: instance Database.Relational.Query.Monad.Class.MonadQuery m => Database.Relational.Query.Monad.Class.MonadQuery (Database.Relational.Query.Monad.Trans.Ordering.Orderings c m)

+ Database.Relational.Query.Monad.Trans.Ordering: instance Database.Relational.Query.Monad.Class.MonadRestrict rc m => Database.Relational.Query.Monad.Class.MonadRestrict rc (Database.Relational.Query.Monad.Trans.Ordering.Orderings c m)

+ Database.Relational.Query.Monad.Trans.Ordering: instance Database.Relational.Query.Monad.Trans.Ordering.ProjectableOrdering (Database.Relational.Query.Projection.Projection c)

+ Database.Relational.Query.Monad.Trans.Ordering: instance GHC.Base.Applicative m => GHC.Base.Applicative (Database.Relational.Query.Monad.Trans.Ordering.Orderings c m)

+ Database.Relational.Query.Monad.Trans.Ordering: instance GHC.Base.Functor m => GHC.Base.Functor (Database.Relational.Query.Monad.Trans.Ordering.Orderings c m)

+ Database.Relational.Query.Monad.Trans.Ordering: instance GHC.Base.Monad m => GHC.Base.Monad (Database.Relational.Query.Monad.Trans.Ordering.Orderings c m)

+ Database.Relational.Query.Monad.Trans.Restricting: instance (GHC.Base.Monad q, GHC.Base.Functor q) => Database.Relational.Query.Monad.Class.MonadRestrict c (Database.Relational.Query.Monad.Trans.Restricting.Restrictings c q)

+ Database.Relational.Query.Monad.Trans.Restricting: instance Control.Monad.Trans.Class.MonadTrans (Database.Relational.Query.Monad.Trans.Restricting.Restrictings c)

+ Database.Relational.Query.Monad.Trans.Restricting: instance Database.Relational.Query.Monad.Class.MonadAggregate m => Database.Relational.Query.Monad.Class.MonadAggregate (Database.Relational.Query.Monad.Trans.Restricting.Restrictings c m)

+ Database.Relational.Query.Monad.Trans.Restricting: instance Database.Relational.Query.Monad.Class.MonadQualify q m => Database.Relational.Query.Monad.Class.MonadQualify q (Database.Relational.Query.Monad.Trans.Restricting.Restrictings c m)

+ Database.Relational.Query.Monad.Trans.Restricting: instance Database.Relational.Query.Monad.Class.MonadQuery q => Database.Relational.Query.Monad.Class.MonadQuery (Database.Relational.Query.Monad.Trans.Restricting.Restrictings c q)

+ Database.Relational.Query.Monad.Trans.Restricting: instance GHC.Base.Applicative m => GHC.Base.Applicative (Database.Relational.Query.Monad.Trans.Restricting.Restrictings c m)

+ Database.Relational.Query.Monad.Trans.Restricting: instance GHC.Base.Functor m => GHC.Base.Functor (Database.Relational.Query.Monad.Trans.Restricting.Restrictings c m)

+ Database.Relational.Query.Monad.Trans.Restricting: instance GHC.Base.Monad m => GHC.Base.Monad (Database.Relational.Query.Monad.Trans.Restricting.Restrictings c m)

+ Database.Relational.Query.Monad.Unique: instance Database.Relational.Query.Monad.Class.MonadQualify Database.Relational.Query.Monad.BaseType.ConfigureQuery Database.Relational.Query.Monad.Unique.QueryUnique

+ Database.Relational.Query.Monad.Unique: instance Database.Relational.Query.Monad.Class.MonadQuery Database.Relational.Query.Monad.Unique.QueryUnique

+ Database.Relational.Query.Monad.Unique: instance GHC.Base.Applicative Database.Relational.Query.Monad.Unique.QueryUnique

+ Database.Relational.Query.Monad.Unique: instance GHC.Base.Functor Database.Relational.Query.Monad.Unique.QueryUnique

+ Database.Relational.Query.Monad.Unique: instance GHC.Base.Monad Database.Relational.Query.Monad.Unique.QueryUnique

+ Database.Relational.Query.Projectable: instance Database.Relational.Query.Projectable.OperatorProjectable (Database.Relational.Query.Expr.Unsafe.Expr Database.Relational.Query.Context.Aggregated)

+ Database.Relational.Query.Projectable: instance Database.Relational.Query.Projectable.OperatorProjectable (Database.Relational.Query.Expr.Unsafe.Expr Database.Relational.Query.Context.Flat)

+ Database.Relational.Query.Projectable: instance Database.Relational.Query.Projectable.OperatorProjectable (Database.Relational.Query.Projection.Projection Database.Relational.Query.Context.Aggregated)

+ Database.Relational.Query.Projectable: instance Database.Relational.Query.Projectable.OperatorProjectable (Database.Relational.Query.Projection.Projection Database.Relational.Query.Context.Flat)

+ Database.Relational.Query.Projectable: instance Database.Relational.Query.Projectable.ProjectableApplicative (Database.Relational.Query.Pi.Unsafe.Pi a)

+ Database.Relational.Query.Projectable: instance Database.Relational.Query.Projectable.ProjectableApplicative (Database.Relational.Query.Projection.Projection c)

+ Database.Relational.Query.Projectable: instance Database.Relational.Query.Projectable.ProjectableApplicative Database.Relational.Query.Projectable.PlaceHolders

+ Database.Relational.Query.Projectable: instance Database.Relational.Query.Projectable.ProjectableFunctor (Database.Relational.Query.Pi.Unsafe.Pi a)

+ Database.Relational.Query.Projectable: instance Database.Relational.Query.Projectable.ProjectableFunctor (Database.Relational.Query.Projection.Projection c)

+ Database.Relational.Query.Projectable: instance Database.Relational.Query.Projectable.ProjectableFunctor Database.Relational.Query.Projectable.PlaceHolders

+ Database.Relational.Query.Projectable: instance Database.Relational.Query.Projectable.ProjectableIdZip Database.Relational.Query.Projectable.PlaceHolders

+ Database.Relational.Query.Projectable: instance Database.Relational.Query.Projectable.ProjectableMaybe (Database.Relational.Query.Expr.Unsafe.Expr p)

+ Database.Relational.Query.Projectable: instance Database.Relational.Query.Projectable.ProjectableMaybe (Database.Relational.Query.Projection.Projection c)

+ Database.Relational.Query.Projectable: instance Database.Relational.Query.Projectable.ProjectableMaybe Database.Relational.Query.Projectable.PlaceHolders

+ Database.Relational.Query.Projectable: instance Database.Relational.Query.Projectable.ProjectableShowSql (Database.Relational.Query.Expr.Unsafe.Expr p)

+ Database.Relational.Query.Projectable: instance Database.Relational.Query.Projectable.ProjectableShowSql (Database.Relational.Query.Projection.Projection c)

+ Database.Relational.Query.Projectable: instance Database.Relational.Query.Projectable.SqlProjectable (Database.Relational.Query.Expr.Unsafe.Expr p)

+ Database.Relational.Query.Projectable: instance Database.Relational.Query.Projectable.SqlProjectable (Database.Relational.Query.Projection.Projection Database.Relational.Query.Context.Aggregated)

+ Database.Relational.Query.Projectable: instance Database.Relational.Query.Projectable.SqlProjectable (Database.Relational.Query.Projection.Projection Database.Relational.Query.Context.Flat)

+ Database.Relational.Query.Projectable: instance Database.Relational.Query.Projectable.SqlProjectable (Database.Relational.Query.Projection.Projection Database.Relational.Query.Context.OverWindow)

+ Database.Relational.Query.ProjectableExtended: instance Database.Relational.Query.ProjectableExtended.AggregatedContext Database.Relational.Query.Context.Aggregated

+ Database.Relational.Query.ProjectableExtended: instance Database.Relational.Query.ProjectableExtended.AggregatedContext Database.Relational.Query.Context.OverWindow

+ Database.Relational.Query.ProjectableExtended: instance Database.Relational.Query.ProjectableExtended.Projectable Database.Relational.Query.Projection.Projection Database.Relational.Query.Expr.Unsafe.Expr

+ Database.Relational.Query.ProjectableExtended: instance Database.Relational.Query.ProjectableExtended.ProjectableFlattenMaybe (GHC.Base.Maybe a) (GHC.Base.Maybe a)

+ Database.Relational.Query.ProjectableExtended: instance Database.Relational.Query.ProjectableExtended.ProjectableFlattenMaybe (GHC.Base.Maybe a) b => Database.Relational.Query.ProjectableExtended.ProjectableFlattenMaybe (GHC.Base.Maybe (GHC.Base.Maybe a)) b

+ Database.Relational.Query.ProjectableExtended: instance Database.Relational.Query.ProjectableExtended.ProjectableRunIdsZip a a

+ Database.Relational.Query.ProjectableExtended: instance Database.Relational.Query.ProjectableExtended.ProjectableRunIdsZip a b => Database.Relational.Query.ProjectableExtended.ProjectableRunIdsZip ((), a) b

+ Database.Relational.Query.Pure: instance (Database.Record.Persistable.PersistableWidth a, Database.Relational.Query.Pure.ShowConstantTermsSQL a) => Database.Relational.Query.Pure.ShowConstantTermsSQL (GHC.Base.Maybe a)

+ Database.Relational.Query.Pure: instance (Database.Relational.Query.Pure.ShowConstantTermsSQL a, Database.Relational.Query.Pure.ShowConstantTermsSQL b) => Database.Relational.Query.Pure.ShowConstantTermsSQL (a, b)

+ Database.Relational.Query.Pure: instance Database.Relational.Query.Pure.ProductConstructor (a -> b -> (a, b))

+ Database.Relational.Query.Pure: instance Database.Relational.Query.Pure.ShowConstantTermsSQL Data.ByteString.Internal.ByteString

+ Database.Relational.Query.Pure: instance Database.Relational.Query.Pure.ShowConstantTermsSQL Data.ByteString.Lazy.Internal.ByteString

+ Database.Relational.Query.Pure: instance Database.Relational.Query.Pure.ShowConstantTermsSQL Data.Text.Internal.Lazy.Text

+ Database.Relational.Query.Pure: instance Database.Relational.Query.Pure.ShowConstantTermsSQL Data.Text.Internal.Text

+ Database.Relational.Query.Pure: instance Database.Relational.Query.Pure.ShowConstantTermsSQL Data.Time.Calendar.Days.Day

+ Database.Relational.Query.Pure: instance Database.Relational.Query.Pure.ShowConstantTermsSQL Data.Time.LocalTime.LocalTime.LocalTime

+ Database.Relational.Query.Pure: instance Database.Relational.Query.Pure.ShowConstantTermsSQL Data.Time.LocalTime.TimeOfDay.TimeOfDay

+ Database.Relational.Query.Pure: instance Database.Relational.Query.Pure.ShowConstantTermsSQL GHC.Base.String

+ Database.Relational.Query.Pure: instance Database.Relational.Query.Pure.ShowConstantTermsSQL GHC.Int.Int16

+ Database.Relational.Query.Pure: instance Database.Relational.Query.Pure.ShowConstantTermsSQL GHC.Int.Int32

+ Database.Relational.Query.Pure: instance Database.Relational.Query.Pure.ShowConstantTermsSQL GHC.Int.Int64

+ Database.Relational.Query.Pure: instance Database.Relational.Query.Pure.ShowConstantTermsSQL GHC.Types.Bool

+ Database.Relational.Query.Pure: instance Database.Relational.Query.Pure.ShowConstantTermsSQL GHC.Types.Char

+ Database.Relational.Query.Pure: instance Database.Relational.Query.Pure.ShowConstantTermsSQL GHC.Types.Double

+ Database.Relational.Query.Pure: instance Database.Relational.Query.Pure.ShowConstantTermsSQL GHC.Types.Float

+ Database.Relational.Query.Pure: instance Database.Relational.Query.Pure.ShowConstantTermsSQL GHC.Types.Int

+ Database.Relational.Query.Scalar: instance Database.Relational.Query.Scalar.ScalarDegree ct => Database.Relational.Query.Scalar.ScalarDegree (GHC.Base.Maybe ct)

+ Database.Relational.Query.Sub: instance GHC.Base.Functor Database.Relational.Query.Sub.Qualified

+ Database.Relational.Query.Sub: instance GHC.Show.Show Database.Relational.Query.Sub.BinOp

+ Database.Relational.Query.Sub: instance GHC.Show.Show Database.Relational.Query.Sub.ProjectionUnit

+ Database.Relational.Query.Sub: instance GHC.Show.Show Database.Relational.Query.Sub.Qualifier

+ Database.Relational.Query.Sub: instance GHC.Show.Show Database.Relational.Query.Sub.SetOp

+ Database.Relational.Query.Sub: instance GHC.Show.Show Database.Relational.Query.Sub.SubQuery

+ Database.Relational.Query.Sub: instance GHC.Show.Show a => GHC.Show.Show (Database.Relational.Query.Sub.Qualified a)

+ Database.Relational.Query.Table: instance GHC.Show.Show Database.Relational.Query.Table.Untyped

+ Database.Relational.Query.Type: [chunkSizeOfInsert] :: Insert a -> Int

+ Database.Relational.Query.Type: [untypeChunkInsert] :: Insert a -> String

+ Database.Relational.Query.Type: [untypeDelete] :: Delete p -> String

+ Database.Relational.Query.Type: [untypeInsertQuery] :: InsertQuery p -> String

+ Database.Relational.Query.Type: [untypeInsert] :: Insert a -> String

+ Database.Relational.Query.Type: [untypeKeyUpdate] :: KeyUpdate p a -> String

+ Database.Relational.Query.Type: [untypeQuery] :: Query p a -> String

+ Database.Relational.Query.Type: [untypeUpdate] :: Update p -> String

+ Database.Relational.Query.Type: [updateKey] :: KeyUpdate p a -> Pi a p

+ Database.Relational.Query.Type: instance Database.Relational.Query.Type.UntypeableNoFetch Database.Relational.Query.Type.Delete

+ Database.Relational.Query.Type: instance Database.Relational.Query.Type.UntypeableNoFetch Database.Relational.Query.Type.Insert

+ Database.Relational.Query.Type: instance Database.Relational.Query.Type.UntypeableNoFetch Database.Relational.Query.Type.Update

+ Database.Relational.Query.Type: instance GHC.Show.Show (Database.Relational.Query.Type.Delete p)

+ Database.Relational.Query.Type: instance GHC.Show.Show (Database.Relational.Query.Type.Insert a)

+ Database.Relational.Query.Type: instance GHC.Show.Show (Database.Relational.Query.Type.InsertQuery p)

+ Database.Relational.Query.Type: instance GHC.Show.Show (Database.Relational.Query.Type.KeyUpdate p a)

+ Database.Relational.Query.Type: instance GHC.Show.Show (Database.Relational.Query.Type.Query p a)

+ Database.Relational.Query.Type: instance GHC.Show.Show (Database.Relational.Query.Type.Update p)

- Database.Relational.Query.Derives: primaryUpdate :: HasConstraintKey Primary r p => Table r -> KeyUpdate p r

+ Database.Relational.Query.Derives: primaryUpdate :: (HasConstraintKey Primary r p) => Table r -> KeyUpdate p r

Files

ChangeLog.md +4/−0
relational-query.cabal +1/−1
src/Database/Relational/Query/Component.hs +11/−8

ChangeLog.md view

@@ -1,3 +1,7 @@+## 0.6.1.0++- Add a configuration flag to pring verbose compile-time messages.+ ## 0.6.0.0  - Increase type safety of interfaces.

relational-query.cabal view

@@ -1,5 +1,5 @@ name:                relational-query-version:             0.6.0.0+version:             0.6.1.0 synopsis:            Typeful, Modular, Relational, algebraic query engine description:         This package contiains typeful relation structure and                      relational-algebraic query building DSL which can

src/Database/Relational/Query/Component.hs view

@@ -17,7 +17,7 @@          ColumnSQL, columnSQL, columnSQL', showsColumnSQL,           -- * Configuration type for query-         Config (productUnitSupport, chunksInsertSize, normalizedTableName),+         Config (productUnitSupport, chunksInsertSize, normalizedTableName, verboseAsCompilerWarning),          defaultConfig,          ProductUnitSupport (..), Duplication (..), @@ -95,17 +95,20 @@ -- | Configuration type. data Config =   Config-  { productUnitSupport   ::  ProductUnitSupport-  , chunksInsertSize     ::  Int-  , normalizedTableName  ::  Bool+  { productUnitSupport        ::  ProductUnitSupport+  , chunksInsertSize          ::  Int+  , normalizedTableName       ::  Bool+  , verboseAsCompilerWarning  ::  Bool   } deriving Show  -- | Default configuration. defaultConfig :: Config-defaultConfig =  Config { productUnitSupport   =  PUSupported-                        , chunksInsertSize     =  256-                        , normalizedTableName  =  True-                        }+defaultConfig =+  Config { productUnitSupport        =  PUSupported+         , chunksInsertSize          =  256+         , normalizedTableName       =  True+         , verboseAsCompilerWarning  =  False+         }  -- | Unit of product is supported or not. data ProductUnitSupport = PUSupported | PUNotSupported  deriving Show