packages feed

beam-core 0.7.2.2 → 0.7.2.3

raw patch · 8 files changed

+49/−25 lines, 8 filesdep ~containersdep ~vector-sizedPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: containers, vector-sized

API changes (from Hackage documentation)

- Database.Beam.Backend.SQL.AST: instance Database.Beam.Backend.SQL.SQL92.HasSqlValueSyntax Database.Beam.Backend.SQL.AST.Value x => Database.Beam.Backend.SQL.SQL92.HasSqlValueSyntax Database.Beam.Backend.SQL.AST.Value (GHC.Base.Maybe x)
- Database.Beam.Backend.Types: instance Database.Beam.Backend.Types.FromBackendRow be x => Database.Beam.Backend.Types.FromBackendRow be (GHC.Base.Maybe x)
- Database.Beam.Backend.URI: instance GHC.Exception.Exception Database.Beam.Backend.URI.BeamOpenURIInvalid
- Database.Beam.Backend.URI: instance GHC.Exception.Exception Database.Beam.Backend.URI.BeamOpenURIUnsupportedScheme
- Database.Beam.Backend.URI: instance GHC.Exception.Exception Database.Beam.Backend.URI.BeamResourceNotFound
- Database.Beam.Query.Internal: instance (Data.Typeable.Internal.Typeable context, Database.Beam.Query.Internal.IsWindowFrameContext context, context ~ Database.Beam.Query.Internal.QWindowFrameContext) => Database.Beam.Query.Internal.WindowFrameContext context
- Database.Beam.Query.Internal: instance (Database.Beam.Query.Internal.IsValueContext a, Data.Typeable.Internal.Typeable a, a ~ Database.Beam.Query.Internal.QValueContext) => Database.Beam.Query.Internal.ValueContext a
- Database.Beam.Schema.Tables: instance (GHC.Generics.Selector f', Database.Beam.Schema.Tables.ChooseSubTableStrategy tbl sub ~ strategy, Database.Beam.Schema.Tables.SubTableStrategyImpl strategy f sub, Database.Beam.Schema.Tables.TagReducesTo f (Database.Beam.Schema.Tables.TableField tbl), Database.Beam.Schema.Tables.Beamable sub) => Database.Beam.Schema.Tables.GDefaultTableFieldSettings (GHC.Generics.S1 f' (GHC.Generics.K1 GHC.Generics.R (sub f)) p)
- Database.Beam.Schema.Tables: instance (fa ~ Database.Beam.Schema.Tables.Columnar f a, ga ~ Database.Beam.Schema.Tables.Columnar g a, ha ~ Database.Beam.Schema.Tables.Columnar h a, ha ~ Database.Beam.Schema.Tables.Columnar h a) => Database.Beam.Schema.Tables.GZipTables f g h (GHC.Generics.K1 GHC.Generics.R (Database.Beam.Backend.Types.Exposed a)) (GHC.Generics.K1 GHC.Generics.R fa) (GHC.Generics.K1 GHC.Generics.R ga) (GHC.Generics.K1 GHC.Generics.R ha)
+ Database.Beam.Backend.SQL.AST: instance Database.Beam.Backend.SQL.SQL92.HasSqlValueSyntax Database.Beam.Backend.SQL.AST.Value x => Database.Beam.Backend.SQL.SQL92.HasSqlValueSyntax Database.Beam.Backend.SQL.AST.Value (GHC.Maybe.Maybe x)
+ Database.Beam.Backend.SQL.Builder: instance Control.Monad.Fail.MonadFail Database.Beam.Backend.SQL.Builder.SqlSyntaxM
+ Database.Beam.Backend.Types: -- backend
+ Database.Beam.Backend.Types: -- | Requirements to marshal a certain type from a database of a particular
+ Database.Beam.Backend.Types: instance Database.Beam.Backend.Types.FromBackendRow be x => Database.Beam.Backend.Types.FromBackendRow be (GHC.Maybe.Maybe x)
+ Database.Beam.Backend.URI: instance GHC.Exception.Type.Exception Database.Beam.Backend.URI.BeamOpenURIInvalid
+ Database.Beam.Backend.URI: instance GHC.Exception.Type.Exception Database.Beam.Backend.URI.BeamOpenURIUnsupportedScheme
+ Database.Beam.Backend.URI: instance GHC.Exception.Type.Exception Database.Beam.Backend.URI.BeamResourceNotFound
+ Database.Beam.Query: (<|>.) :: (SqlJustable a (QGenExpr ctxt syntax s y), SqlDeconstructMaybe syntax (QGenExpr ctxt syntax s y) a s) => QGenExpr ctxt syntax s y -> QGenExpr ctxt syntax s y -> QGenExpr ctxt syntax s y
+ Database.Beam.Query: infixl 3 <|>.
+ Database.Beam.Query: type family HaskellLiteralForQExpr x = a
+ Database.Beam.Query.Internal: instance (Data.Typeable.Internal.Typeable context, Database.Beam.Query.Internal.IsWindowFrameContext context, context Data.Type.Equality.~ Database.Beam.Query.Internal.QWindowFrameContext) => Database.Beam.Query.Internal.WindowFrameContext context
+ Database.Beam.Query.Internal: instance (Database.Beam.Query.Internal.IsValueContext a, Data.Typeable.Internal.Typeable a, a Data.Type.Equality.~ Database.Beam.Query.Internal.QValueContext) => Database.Beam.Query.Internal.ValueContext a
+ Database.Beam.Query.Types: type family QExprToField x
+ Database.Beam.Schema: -- must be an instance of <a>Generic</a>.
+ Database.Beam.Schema: -- order to play nicely with the default deriving mechanism, this type
+ Database.Beam.Schema: -- | A data type representing the types of primary keys for this table. In
+ Database.Beam.Schema: type family Columnar (f :: * -> *) x
+ Database.Beam.Schema.Tables: -- must be an instance of <a>Generic</a>.
+ Database.Beam.Schema.Tables: -- order to play nicely with the default deriving mechanism, this type
+ Database.Beam.Schema.Tables: -- | A data type representing the types of primary keys for this table. In
+ Database.Beam.Schema.Tables: infixr 6 :*:
+ Database.Beam.Schema.Tables: instance (GHC.Generics.Selector f', Database.Beam.Schema.Tables.ChooseSubTableStrategy tbl sub Data.Type.Equality.~ strategy, Database.Beam.Schema.Tables.SubTableStrategyImpl strategy f sub, Database.Beam.Schema.Tables.TagReducesTo f (Database.Beam.Schema.Tables.TableField tbl), Database.Beam.Schema.Tables.Beamable sub) => Database.Beam.Schema.Tables.GDefaultTableFieldSettings (GHC.Generics.S1 f' (GHC.Generics.K1 GHC.Generics.R (sub f)) p)
+ Database.Beam.Schema.Tables: instance (fa Data.Type.Equality.~ Database.Beam.Schema.Tables.Columnar f a, ga Data.Type.Equality.~ Database.Beam.Schema.Tables.Columnar g a, ha Data.Type.Equality.~ Database.Beam.Schema.Tables.Columnar h a, ha Data.Type.Equality.~ Database.Beam.Schema.Tables.Columnar h a) => Database.Beam.Schema.Tables.GZipTables f g h (GHC.Generics.K1 GHC.Generics.R (Database.Beam.Backend.Types.Exposed a)) (GHC.Generics.K1 GHC.Generics.R fa) (GHC.Generics.K1 GHC.Generics.R ga) (GHC.Generics.K1 GHC.Generics.R ha)
- Database.Beam: class (BeamBackend be, Monad m, MonadIO m, Sql92SanityCheck syntax) => MonadBeam syntax be handle m | m -> syntax be handle
+ Database.Beam: class (BeamBackend be, Monad m, MonadIO m, MonadFail m, Sql92SanityCheck syntax) => MonadBeam syntax be handle m | m -> syntax be handle
- Database.Beam: class Monad m => MonadIO (m :: * -> *)
+ Database.Beam: class Monad m => MonadIO (m :: Type -> Type)
- Database.Beam.Backend: class (BeamBackend be, Monad m, MonadIO m, Sql92SanityCheck syntax) => MonadBeam syntax be handle m | m -> syntax be handle
+ Database.Beam.Backend: class (BeamBackend be, Monad m, MonadIO m, MonadFail m, Sql92SanityCheck syntax) => MonadBeam syntax be handle m | m -> syntax be handle
- Database.Beam.Backend.SQL: class (BeamBackend be, Monad m, MonadIO m, Sql92SanityCheck syntax) => MonadBeam syntax be handle m | m -> syntax be handle
+ Database.Beam.Backend.SQL: class (BeamBackend be, Monad m, MonadIO m, MonadFail m, Sql92SanityCheck syntax) => MonadBeam syntax be handle m | m -> syntax be handle
- Database.Beam.Backend.SQL.AST: DataTypeBit :: Bool -> (Maybe Word) -> DataType
+ Database.Beam.Backend.SQL.AST: DataTypeBit :: Bool -> Maybe Word -> DataType
- Database.Beam.Backend.SQL.AST: DataTypeChar :: Bool -> (Maybe Word) -> (Maybe Text) -> DataType
+ Database.Beam.Backend.SQL.AST: DataTypeChar :: Bool -> Maybe Word -> Maybe Text -> DataType
- Database.Beam.Backend.SQL.AST: DataTypeDecimal :: (Maybe (Word, Maybe Word)) -> DataType
+ Database.Beam.Backend.SQL.AST: DataTypeDecimal :: Maybe (Word, Maybe Word) -> DataType
- Database.Beam.Backend.SQL.AST: DataTypeFloat :: (Maybe Word) -> DataType
+ Database.Beam.Backend.SQL.AST: DataTypeFloat :: Maybe Word -> DataType
- Database.Beam.Backend.SQL.AST: DataTypeNationalChar :: Bool -> (Maybe Word) -> DataType
+ Database.Beam.Backend.SQL.AST: DataTypeNationalChar :: Bool -> Maybe Word -> DataType
- Database.Beam.Backend.SQL.AST: DataTypeNumeric :: (Maybe (Word, Maybe Word)) -> DataType
+ Database.Beam.Backend.SQL.AST: DataTypeNumeric :: Maybe (Word, Maybe Word) -> DataType
- Database.Beam.Backend.SQL.AST: DataTypeTime :: (Maybe Word) -> Bool -> DataType
+ Database.Beam.Backend.SQL.AST: DataTypeTime :: Maybe Word -> Bool -> DataType
- Database.Beam.Backend.SQL.AST: DataTypeTimeStamp :: (Maybe Word) -> Bool -> DataType
+ Database.Beam.Backend.SQL.AST: DataTypeTimeStamp :: Maybe Word -> Bool -> DataType
- Database.Beam.Backend.SQL.AST: ExpressionAgg :: Text -> (Maybe SetQuantifier) -> [Expression] -> Expression
+ Database.Beam.Backend.SQL.AST: ExpressionAgg :: Text -> Maybe SetQuantifier -> [Expression] -> Expression
- Database.Beam.Backend.SQL.AST: ExpressionCompOp :: Text -> (Maybe ComparatorQuantifier) -> Expression -> Expression -> Expression
+ Database.Beam.Backend.SQL.AST: ExpressionCompOp :: Text -> Maybe ComparatorQuantifier -> Expression -> Expression -> Expression
- Database.Beam.Backend.SQL.AST: FromTable :: TableSource -> (Maybe Text) -> From
+ Database.Beam.Backend.SQL.AST: FromTable :: TableSource -> Maybe Text -> From
- Database.Beam.Backend.SQL.AST: InnerJoin :: From -> From -> (Maybe Expression) -> From
+ Database.Beam.Backend.SQL.AST: InnerJoin :: From -> From -> Maybe Expression -> From
- Database.Beam.Backend.SQL.AST: LeftJoin :: From -> From -> (Maybe Expression) -> From
+ Database.Beam.Backend.SQL.AST: LeftJoin :: From -> From -> Maybe Expression -> From
- Database.Beam.Backend.SQL.AST: OuterJoin :: From -> From -> (Maybe Expression) -> From
+ Database.Beam.Backend.SQL.AST: OuterJoin :: From -> From -> Maybe Expression -> From
- Database.Beam.Backend.SQL.AST: RightJoin :: From -> From -> (Maybe Expression) -> From
+ Database.Beam.Backend.SQL.AST: RightJoin :: From -> From -> Maybe Expression -> From
- Database.Beam.Query: allIn_ :: forall s a expr. (IsSql92ExpressionSyntax expr) => [QExpr expr s a] -> QQuantified expr s a
+ Database.Beam.Query: allIn_ :: forall s a expr. IsSql92ExpressionSyntax expr => [QExpr expr s a] -> QQuantified expr s a
- Database.Beam.Query: anyIn_ :: forall s a expr. (IsSql92ExpressionSyntax expr) => [QExpr expr s a] -> QQuantified expr s a
+ Database.Beam.Query: anyIn_ :: forall s a expr. IsSql92ExpressionSyntax expr => [QExpr expr s a] -> QQuantified expr s a
- Database.Beam.Query: filter_ :: forall r select db s. (IsSql92SelectSyntax select) => (r -> QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s Bool) -> Q select db s r -> Q select db s r
+ Database.Beam.Query: filter_ :: forall r select db s. IsSql92SelectSyntax select => (r -> QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s Bool) -> Q select db s r -> Q select db s r
- Database.Beam.Query: filter_' :: forall r select db s. (IsSql92SelectSyntax select) => (r -> QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s SqlBool) -> Q select db s r -> Q select db s r
+ Database.Beam.Query: filter_' :: forall r select db s. IsSql92SelectSyntax select => (r -> QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s SqlBool) -> Q select db s r -> Q select db s r
- Database.Beam.Query: guard_ :: forall select db s. (IsSql92SelectSyntax select) => QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s Bool -> Q select db s ()
+ Database.Beam.Query: guard_ :: forall select db s. IsSql92SelectSyntax select => QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s Bool -> Q select db s ()
- Database.Beam.Query.Internal: QFrameBounds :: (Maybe syntax) -> QFrameBounds syntax
+ Database.Beam.Query.Internal: QFrameBounds :: Maybe syntax -> QFrameBounds syntax
- Database.Beam.Query.Internal: QWindow :: (WithExprContext syntax) -> QWindow syntax s
+ Database.Beam.Query.Internal: QWindow :: WithExprContext syntax -> QWindow syntax s
- Database.Beam.Schema: TableLens :: (Lens' (db f) (f x)) -> TableLens f db
+ Database.Beam.Schema: TableLens :: Lens' (db f) (f x) -> TableLens f db
- Database.Beam.Schema.Tables: Columnar' :: (Columnar f a) -> Columnar' f a
+ Database.Beam.Schema.Tables: Columnar' :: Columnar f a -> Columnar' f a
- Database.Beam.Schema.Tables: ComposeColumnar :: (f (Columnar g a)) -> ComposeColumnar f g a
+ Database.Beam.Schema.Tables: ComposeColumnar :: f (Columnar g a) -> ComposeColumnar f g a
- Database.Beam.Schema.Tables: FieldRenamer :: entity -> entity -> FieldRenamer entity
+ Database.Beam.Schema.Tables: FieldRenamer :: (entity -> entity) -> FieldRenamer entity
- Database.Beam.Schema.Tables: data (:*:) (f :: k -> *) (g :: k -> *) (p :: k) :: forall k. () => k -> * -> k -> * -> k -> *
+ Database.Beam.Schema.Tables: data (:*:) (f :: k -> Type) (g :: k -> Type) (p :: k) :: forall k. () => k -> Type -> k -> Type -> k -> Type

Files

Database/Beam/Backend/SQL.hs view
@@ -10,6 +10,7 @@ import Database.Beam.Backend.Types  import Control.Monad.IO.Class+import Control.Monad.Fail (MonadFail)  -- * MonadBeam class @@ -29,7 +30,7 @@ --   strategies. More complicated strategies (for example, Postgres's @COPY@) --   are supported in individual backends. See the documentation of those --   backends for more details.-class (BeamBackend be, Monad m, MonadIO m, Sql92SanityCheck syntax) =>+class (BeamBackend be, Monad m, MonadIO m, MonadFail m, Sql92SanityCheck syntax) =>   MonadBeam syntax be handle m | m -> syntax be handle where    {-# MINIMAL withDatabaseDebug, runReturningMany #-}
Database/Beam/Backend/SQL/Builder.hs view
@@ -33,6 +33,7 @@ import           Data.Hashable import           Data.Int import           Data.String+import qualified Control.Monad.Fail as Fail #if !MIN_VERSION_base(4, 11, 0) import           Data.Semigroup #endif@@ -507,8 +508,10 @@   type BackendFromField SqlSyntaxBackend = Trivial  newtype SqlSyntaxM a = SqlSyntaxM (IO a)-  deriving (Applicative, Functor, Monad, MonadIO)+  deriving (Applicative, Functor, Monad, MonadIO, Fail.MonadFail)  instance MonadBeam SqlSyntaxBuilder SqlSyntaxBackend SqlSyntaxBackend SqlSyntaxM where-  withDatabaseDebug _ _ _ = fail "absurd"-  runReturningMany _ _ = fail "absurd"+  withDatabaseDebug _ _ _ = Fail.fail "absurd"+  runReturningMany _ _ = Fail.fail "absurd"++
Database/Beam/Backend/Types.hs view
@@ -54,7 +54,7 @@   valuesNeeded :: Proxy be -> Proxy a -> Int   valuesNeeded _ _ = 1 --- | newtype mainly used to inspect tho tag structure of a particular+-- | newtype mainly used to inspect the tag structure of a particular --   'Beamable'. Prevents overlapping instances in some case. Usually not used --   in end-user code. data Exposed x
Database/Beam/Query/Combinators.hs view
@@ -1,3 +1,4 @@+{-# LANGUAGE CPP #-} {-# LANGUAGE UndecidableInstances #-}  module Database.Beam.Query.Combinators@@ -36,6 +37,7 @@     , SqlDeconstructMaybe(..)     , SqlOrderable     , QIfCond, QIfElse+    , (<|>.)      , limit_, offset_ @@ -72,7 +74,9 @@  import Database.Beam.Schema.Tables +#if !MIN_VERSION_base(4, 11, 0) import Control.Monad.Writer+#endif import Control.Monad.Identity import Control.Monad.Free import Control.Applicative@@ -899,3 +903,12 @@       let QExpr onJust' = onJust (changeBeamRep (\(Columnar' (QExpr e)) -> Columnar' (QExpr e)) tbl)           QExpr cond = isJust_ tbl       in QExpr (\tblPfx -> caseE [(cond tblPfx, onJust' tblPfx)] (onNothing tblPfx))++infixl 3 <|>.+(<|>.) :: ( SqlJustable a (QGenExpr ctxt syntax s y)+          , SqlDeconstructMaybe syntax (QGenExpr ctxt syntax s y) a s+          )+       => QGenExpr ctxt syntax s y+       -> QGenExpr ctxt syntax s y+       -> QGenExpr ctxt syntax s y+l <|>. r = maybe_ r just_ l
Database/Beam/Query/SQL92.hs view
@@ -1,5 +1,6 @@ {-# OPTIONS_GHC -fno-warn-name-shadowing -fno-warn-unused-binds #-} {-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE CPP #-}  module Database.Beam.Query.SQL92     ( buildSql92Query' ) where@@ -11,7 +12,9 @@  import           Control.Monad.Free.Church import           Control.Monad.Free+#if !MIN_VERSION_base(4, 11, 0) import           Control.Monad.Writer+#endif  import           Data.Maybe import           Data.String
Database/Beam/Schema/Lenses.hs view
@@ -1,4 +1,5 @@ {-# LANGUAGE PolyKinds #-}+{-# LANGUAGE UndecidableInstances #-} module Database.Beam.Schema.Lenses     ( tableLenses     , TableLens(..)
beam-core.cabal view
@@ -2,7 +2,7 @@ -- see http://haskell.org/cabal/users-guide/  name:                beam-core-version:             0.7.2.2+version:             0.7.2.3 synopsis:            Type-safe, feature-complete SQL query and manipulation interface for Haskell description:         Beam is a Haskell library for type-safe querying and manipulation of SQL databases.                      Beam is modular and supports various backends. In order to use beam, you will need to use@@ -58,13 +58,13 @@                        mtl          >=2.1     && <2.3,                        microlens    >=0.4     && <0.5,                        ghc-prim     >=0.5     && <0.6,-                       free         >=4.12    && <5.1,+                       free         >=4.12    && <5.2,                        dlist        >=0.7.1.2 && <0.9,                        time         >=1.6     && <1.10,                        hashable     >=1.1     && <1.3,                        network-uri  >=2.6     && <2.7,-                       containers   >=0.5     && <0.6,-                       vector-sized >=0.5     && <1.1,+                       containers   >=0.5     && <0.7,+                       vector-sized >=0.5     && <1.3,                        tagged       >=0.8     && <0.9   Default-language:    Haskell2010   default-extensions:  ScopedTypeVariables, OverloadedStrings, GADTs, RecursiveDo, FlexibleInstances, FlexibleContexts, TypeFamilies,
test/Database/Beam/Test/Schema.hs view
@@ -234,20 +234,16 @@ type BDepartmentVehicule    = BDepartmentVehiculeT Identity data BDepartmentVehiculeT f = BDepartmentVehicule       { _bDepartament  :: PrimaryKey DepartmentT f-      , _bRelatesTo    :: VehiculeT f                +      , _bRelatesTo    :: VehiculeT f       , _bMetaInfo     :: VehiculeInformationT (Nullable f)       } deriving Generic--- --- ["departament__name","relates_to__id","relates_to__type","relates_to__of_wheels","meta_info__price"] -- instance (Beamable metaInfo, Beamable  prop) => Beamable (DepartamentRelatedT metaInfo prop)   instance (Table metaInfo, Table  prop) => Table    (DepartamentRelatedT metaInfo prop) where-  data PrimaryKey (DepartamentRelatedT metaInfo prop) f = DepReKeyA (PrimaryKey DepartmentT f) -                                                                    (PrimaryKey prop f) +  data PrimaryKey (DepartamentRelatedT metaInfo prop) f = DepReKeyA (PrimaryKey DepartmentT f)+                                                                    (PrimaryKey prop f)                                                                     deriving(Generic)   primaryKey = DepReKeyA <$> _aDepartament <*> (primaryKey._aRelatesTo) @@ -280,19 +276,25 @@      data PrimaryKey VehiculeInformationT f = VehiculeInformationKey  deriving(Generic)      primaryKey _ = VehiculeInformationKey -----instance Beamable BDepartmentVehiculeT +instance Beamable BDepartmentVehiculeT instance Beamable (PrimaryKey BDepartmentVehiculeT) instance Table BDepartmentVehiculeT where-  data PrimaryKey BDepartmentVehiculeT f = DepReKeyB (PrimaryKey DepartmentT f) -                                                     (PrimaryKey VehiculeT   f) +  data PrimaryKey BDepartmentVehiculeT f = DepReKeyB (PrimaryKey DepartmentT f)+                                                     (PrimaryKey VehiculeT   f)                                                      deriving(Generic)   primaryKey = DepReKeyB <$> _bDepartament <*> (primaryKey._bRelatesTo) -+data NoPrimaryKeyT f+    = NoPrimaryKeyT+    { _npkField1 :: C f Text+    , _npkField2 :: C f Double+    } deriving Generic+instance Beamable NoPrimaryKeyT+instance Table NoPrimaryKeyT where+    data PrimaryKey NoPrimaryKeyT f = NoPrimaryKey+        deriving Generic+    primaryKey _ = NoPrimaryKey+instance Beamable (PrimaryKey NoPrimaryKeyT)  -- * Database schema is derived correctly @@ -301,9 +303,10 @@     { _employees            :: f (TableEntity EmployeeT)     , _departments          :: f (TableEntity DepartmentT)     , _roles                :: f (TableEntity RoleT)-    , _funny                :: f (TableEntity FunnyT) +    , _funny                :: f (TableEntity FunnyT)     , _departmentVehiculesA :: f (TableEntity ADepartmentVehiculeT)     , _departmentVehiculesB :: f (TableEntity BDepartmentVehiculeT)+    , _noPrimaryKey         :: f (TableEntity NoPrimaryKeyT)     } deriving Generic instance Database be EmployeeDb