diff --git a/README.md b/README.md
index c297a20..5cf4dc6 100644
--- a/README.md
+++ b/README.md
@@ -42,7 +42,18 @@ You can use the SQLite CodeFirst in projects that target the following framework
 - .NET 4.6.1 (use net45)
 
 ## How to use
+The functionality is exposed by using implementations of the `IDbInitializer<>` interface.
+Depending on your need, you can choose from the following initializers:
+- SqliteCreateDatabaseIfNotExists 
+- SqliteDropCreateDatabaseAlways
+- SqliteDropCreateDatabaseWhenModelChanges
+
+If you want to have more control, you can use the `SqliteDatabaseCreator` (implements `IDatabaseCreator`) which lets you control the creation of the SQLite database.
+Or for even more control, use the `SqliteSqlGenerator` (implements `ISqlGenerator`), which lets you generate the SQL code based on your `EdmModel`.
+
 When you want to let the Entity Framework create database if it does not exist, just set `SqliteDropCreateDatabaseAlways<>` or `SqliteCreateDatabaseIfNotExists<>` as your `IDbInitializer<>`.
+
+### Initializer Sample
 ```csharp
 public class MyDbContext : DbContext
 {
@@ -56,9 +67,12 @@ public class MyDbContext : DbContext
     }
 }
 ```
+Notice that the `SqliteDropCreateDatabaseWhenModelChanges<>` initializer will create a additional table in your database.
+This table is used to store some information to detect model changes. If you want to use a own entity/table you can implement the
+`IHistory` interface and pass the type of your entity as parameter in the to the constructor from the initializer. 
 
 In a more advanced scenario, you may want to populate some core- or test-data after the database was created.
-To do this, inherit from `SqliteDropCreateDatabaseAlways<>` or `SqliteCreateDatabaseIfNotExists<>` and override the `Seed(MyDbContext context)` function.
+To do this, inherit from `SqliteDropCreateDatabaseAlways<>`, `SqliteCreateDatabaseIfNotExists<>` or `SqliteDropCreateDatabaseWhenModelChanges<>` and override the `Seed(MyDbContext context)` function.
 This function will be called in a transaction once the database was created.  This function is only executed if a new database was successfully created.
 ```csharp
 public class MyDbContextInitializer : SqliteDropCreateDatabaseAlways<MyDbContext>
@@ -73,6 +87,32 @@ public class MyDbContextInitializer : SqliteDropCreateDatabaseAlways<MyDbContext
 }
 ```
 
+### SqliteDatabaseCreator Sample
+```csharp
+public class MyContext : DbContext
+{
+    protected override void OnModelCreating(DbModelBuilder modelBuilder)
+    {
+        var model = modelBuilder.Build(Database.Connection);
+        IDatabaseCreator sqliteDatabaseCreator = new SqliteDatabaseCreator();
+        sqliteDatabaseCreator.Create(Database, model);
+    }
+}
+```
+
+### SqliteSqlGenerator Sample
+```csharp
+public class MyContext : DbContext
+{
+    protected override void OnModelCreating(DbModelBuilder modelBuilder)
+    {
+        var model = modelBuilder.Build(Database.Connection);
+        ISqlGenerator sqlGenerator = new SqliteSqlGenerator();
+        string sql = sqlGenerator.Generate(model.StoreModel);
+    }
+}
+```
+
 ## Hints
 If you try to reinstall the NuGet-Packages (e.g. if you want to downgrade to .NET 4.0), the app.config will be overwritten and you may getting an exception when you try to run the console project.
 In this case please check the following issue: https://github.com/msallin/SQLiteCodeFirst/issues/13.
diff --git a/SQLite.CodeFirst.Console/App.config b/SQLite.CodeFirst.Console/App.config
index b7d5048..9fa9559 100644
--- a/SQLite.CodeFirst.Console/App.config
+++ b/SQLite.CodeFirst.Console/App.config
@@ -11,9 +11,10 @@
   </startup>
   <system.data>
     <DbProviderFactories>
-      <remove invariant="System.Data.SQLite"/>
       <remove invariant="System.Data.SQLite.EF6" />
-      <add name="SQLite Data Provider" invariant="System.Data.SQLite" description=".Net Framework Data Provider for SQLite" type="System.Data.SQLite.SQLiteFactory, System.Data.SQLite" />
+      <add name="SQLite Data Provider (Entity Framework 6)" invariant="System.Data.SQLite.EF6" description=".NET Framework Data Provider for SQLite (Entity Framework 6)" type="System.Data.SQLite.EF6.SQLiteProviderFactory, System.Data.SQLite.EF6" />
+      <remove invariant="System.Data.SQLite" />
+      <add name="SQLite Data Provider" invariant="System.Data.SQLite" description=".NET Framework Data Provider for SQLite" type="System.Data.SQLite.SQLiteFactory, System.Data.SQLite" />
     </DbProviderFactories>
   </system.data>
   <entityFramework>
@@ -25,6 +26,7 @@
     <providers>
       <provider invariantName="System.Data.SqlClient" type="System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer" />
       <provider invariantName="System.Data.SQLite" type="System.Data.SQLite.EF6.SQLiteProviderServices, System.Data.SQLite.EF6" />
+      <provider invariantName="System.Data.SQLite.EF6" type="System.Data.SQLite.EF6.SQLiteProviderServices, System.Data.SQLite.EF6" />
     </providers>
   </entityFramework>
 </configuration>
\ No newline at end of file
diff --git a/SQLite.CodeFirst.Console/Entity/CustomHistory.cs b/SQLite.CodeFirst.Console/Entity/CustomHistory.cs
new file mode 100644
index 0000000..51ad92c
--- /dev/null
+++ b/SQLite.CodeFirst.Console/Entity/CustomHistory.cs
@@ -0,0 +1,12 @@
+using System;
+
+namespace SQLite.CodeFirst.Console.Entity
+{
+    public class CustomHistory : IHistory
+    {
+        public int Id { get; set; }
+        public string Hash { get; set; }
+        public string Context { get; set; }
+        public DateTime CreateDate { get; set; }
+    }
+}
diff --git a/SQLite.CodeFirst.Console/FootballDbContext.cs b/SQLite.CodeFirst.Console/FootballDbContext.cs
index 6f0ed9e..e3eabcf 100644
--- a/SQLite.CodeFirst.Console/FootballDbContext.cs
+++ b/SQLite.CodeFirst.Console/FootballDbContext.cs
@@ -1,6 +1,4 @@
-using System.Collections.Generic;
-using System.Data.Entity;
-using System.Data.Entity.ModelConfiguration.Conventions;
+using System.Data.Entity;
 using SQLite.CodeFirst.Console.Entity;
 
 namespace SQLite.CodeFirst.Console
@@ -16,8 +14,6 @@ public FootballDbContext()
 
         protected override void OnModelCreating(DbModelBuilder modelBuilder)
         {
-            modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
-
             ConfigureTeamEntity(modelBuilder);
             ConfigureStadionEntity(modelBuilder);
             ConfigureCoachEntity(modelBuilder);
@@ -61,51 +57,4 @@ private static void ConfigurePlayerEntity(DbModelBuilder modelBuilder)
                 .WillCascadeOnDelete(true);
         }
     }
-
-    public class FootballDbInitializer : SqliteDropCreateDatabaseAlways<FootballDbContext>
-    {
-        public FootballDbInitializer(DbModelBuilder modelBuilder)
-            : base(modelBuilder)
-        { }
-
-        protected override void Seed(FootballDbContext context)
-        {
-            context.Set<Team>().Add(new Team
-            {
-                Name = "YB",
-                Coach = new Coach
-                {
-                    City = "Zürich",
-                    FirstName = "Masssaman",
-                    LastName = "Nachn",
-                    Street = "Testingstreet 844"
-                },
-                Players = new List<Player>
-                {
-                    new Player
-                    {
-                        City = "Bern",
-                        FirstName = "Marco",
-                        LastName = "Bürki",
-                        Street = "Wunderstrasse 43",
-                        Number = 12
-                    },
-                    new Player
-                    {
-                        City = "Berlin",
-                        FirstName = "Alain",
-                        LastName = "Rochat",
-                        Street = "Wonderstreet 13",
-                        Number = 14
-                    }
-                },
-                Stadion = new Stadion
-                {
-                    Name = "Stade de Suisse",
-                    City = "Bern",
-                    Street = "Papiermühlestrasse 71"
-                }
-            });
-        }
-    }
 }
diff --git a/SQLite.CodeFirst.Console/FootballDbInitializer.cs b/SQLite.CodeFirst.Console/FootballDbInitializer.cs
new file mode 100644
index 0000000..8aa6199
--- /dev/null
+++ b/SQLite.CodeFirst.Console/FootballDbInitializer.cs
@@ -0,0 +1,53 @@
+using System.Collections.Generic;
+using System.Data.Entity;
+using SQLite.CodeFirst.Console.Entity;
+
+namespace SQLite.CodeFirst.Console
+{
+    public class FootballDbInitializer : SqliteDropCreateDatabaseWhenModelChanges<FootballDbContext>
+    {
+        public FootballDbInitializer(DbModelBuilder modelBuilder)
+            : base(modelBuilder, typeof(CustomHistory))
+        { }
+
+        protected override void Seed(FootballDbContext context)
+        {
+            context.Set<Team>().Add(new Team
+            {
+                Name = "YB",
+                Coach = new Coach
+                {
+                    City = "Zürich",
+                    FirstName = "Masssaman",
+                    LastName = "Nachn",
+                    Street = "Testingstreet 844"
+                },
+                Players = new List<Player>
+                {
+                    new Player
+                    {
+                        City = "Bern",
+                        FirstName = "Marco",
+                        LastName = "Bürki",
+                        Street = "Wunderstrasse 43",
+                        Number = 12
+                    },
+                    new Player
+                    {
+                        City = "Berlin",
+                        FirstName = "Alain",
+                        LastName = "Rochat",
+                        Street = "Wonderstreet 13",
+                        Number = 14
+                    }
+                },
+                Stadion = new Stadion
+                {
+                    Name = "Stade de Suisse",
+                    City = "Bern",
+                    Street = "Papiermühlestrasse 71"
+                }
+            });
+        }
+    }
+}
\ No newline at end of file
diff --git a/SQLite.CodeFirst.Console/SQLite.CodeFirst.Console.csproj b/SQLite.CodeFirst.Console/SQLite.CodeFirst.Console.csproj
index e91b289..c1379f4 100644
--- a/SQLite.CodeFirst.Console/SQLite.CodeFirst.Console.csproj
+++ b/SQLite.CodeFirst.Console/SQLite.CodeFirst.Console.csproj
@@ -53,15 +53,17 @@
     <Reference Include="System.ComponentModel.DataAnnotations" />
     <Reference Include="System.Configuration" />
     <Reference Include="System.Core" />
-    <Reference Include="System.Data.SQLite, Version=1.0.97.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Data.SQLite.Core.1.0.97.0\lib\net451\System.Data.SQLite.dll</HintPath>
+    <Reference Include="System.Data.SQLite, Version=1.0.99.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.Data.SQLite.Core.1.0.99.0\lib\net451\System.Data.SQLite.dll</HintPath>
       <Private>True</Private>
     </Reference>
-    <Reference Include="System.Data.SQLite.EF6">
-      <HintPath>..\packages\System.Data.SQLite.EF6.1.0.97.0\lib\net451\System.Data.SQLite.EF6.dll</HintPath>
+    <Reference Include="System.Data.SQLite.EF6, Version=1.0.99.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.Data.SQLite.EF6.1.0.99.0\lib\net451\System.Data.SQLite.EF6.dll</HintPath>
+      <Private>True</Private>
     </Reference>
-    <Reference Include="System.Data.SQLite.Linq">
-      <HintPath>..\packages\System.Data.SQLite.Linq.1.0.97.0\lib\net451\System.Data.SQLite.Linq.dll</HintPath>
+    <Reference Include="System.Data.SQLite.Linq, Version=1.0.99.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.Data.SQLite.Linq.1.0.99.0\lib\net451\System.Data.SQLite.Linq.dll</HintPath>
+      <Private>True</Private>
     </Reference>
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
@@ -77,12 +79,14 @@
       <Link>Properties\AssemblyVersionInfo.cs</Link>
     </Compile>
     <Compile Include="Entity\Coach.cs" />
+    <Compile Include="Entity\CustomHistory.cs" />
     <Compile Include="Entity\IEntity.cs" />
     <Compile Include="Entity\Person.cs" />
     <Compile Include="Entity\Player.cs" />
     <Compile Include="Entity\Stadion.cs" />
     <Compile Include="Entity\Team.cs" />
     <Compile Include="FootballDbContext.cs" />
+    <Compile Include="FootballDbInitializer.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
@@ -102,10 +106,10 @@
       <ErrorText>This project references NuGet package(s) that are missing on this computer. Enable NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
     </PropertyGroup>
     <Error Condition="!Exists('$(SolutionDir)\.nuget\NuGet.targets')" Text="$([System.String]::Format('$(ErrorText)', '$(SolutionDir)\.nuget\NuGet.targets'))" />
-    <Error Condition="!Exists('..\packages\System.Data.SQLite.Core.1.0.97.0\build\net451\System.Data.SQLite.Core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\System.Data.SQLite.Core.1.0.97.0\build\net451\System.Data.SQLite.Core.targets'))" />
+    <Error Condition="!Exists('..\packages\System.Data.SQLite.Core.1.0.99.0\build\net451\System.Data.SQLite.Core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\System.Data.SQLite.Core.1.0.99.0\build\net451\System.Data.SQLite.Core.targets'))" />
   </Target>
   <Import Project="$(SolutionDir)\.nuget\NuGet.targets" Condition="Exists('$(SolutionDir)\.nuget\NuGet.targets')" />
-  <Import Project="..\packages\System.Data.SQLite.Core.1.0.97.0\build\net451\System.Data.SQLite.Core.targets" Condition="Exists('..\packages\System.Data.SQLite.Core.1.0.97.0\build\net451\System.Data.SQLite.Core.targets')" />
+  <Import Project="..\packages\System.Data.SQLite.Core.1.0.99.0\build\net451\System.Data.SQLite.Core.targets" Condition="Exists('..\packages\System.Data.SQLite.Core.1.0.99.0\build\net451\System.Data.SQLite.Core.targets')" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
diff --git a/SQLite.CodeFirst.Console/packages.config b/SQLite.CodeFirst.Console/packages.config
index b4537bc..e3d5eea 100644
--- a/SQLite.CodeFirst.Console/packages.config
+++ b/SQLite.CodeFirst.Console/packages.config
@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="EntityFramework" version="6.1.3" targetFramework="net452" userInstalled="true" />
-  <package id="System.Data.SQLite" version="1.0.97.0" targetFramework="net452" userInstalled="true" />
-  <package id="System.Data.SQLite.Core" version="1.0.97.0" targetFramework="net452" userInstalled="true" />
-  <package id="System.Data.SQLite.EF6" version="1.0.97.0" targetFramework="net452" userInstalled="true" />
-  <package id="System.Data.SQLite.Linq" version="1.0.97.0" targetFramework="net452" userInstalled="true" />
+  <package id="System.Data.SQLite" version="1.0.99.0" targetFramework="net452" userInstalled="true" />
+  <package id="System.Data.SQLite.Core" version="1.0.99.0" targetFramework="net452" userInstalled="true" />
+  <package id="System.Data.SQLite.EF6" version="1.0.99.0" targetFramework="net452" userInstalled="true" />
+  <package id="System.Data.SQLite.Linq" version="1.0.99.0" targetFramework="net452" userInstalled="true" />
 </packages>
\ No newline at end of file
diff --git a/SQLite.CodeFirst/SqliteCreateDatabaseIfNotExists.cs b/SQLite.CodeFirst/DbInitializers/SqliteCreateDatabaseIfNotExists.cs
similarity index 100%
rename from SQLite.CodeFirst/SqliteCreateDatabaseIfNotExists.cs
rename to SQLite.CodeFirst/DbInitializers/SqliteCreateDatabaseIfNotExists.cs
diff --git a/SQLite.CodeFirst/SqliteDropCreateDatabaseAlways.cs b/SQLite.CodeFirst/DbInitializers/SqliteDropCreateDatabaseAlways.cs
similarity index 95%
rename from SQLite.CodeFirst/SqliteDropCreateDatabaseAlways.cs
rename to SQLite.CodeFirst/DbInitializers/SqliteDropCreateDatabaseAlways.cs
index 91a8c19..b022345 100644
--- a/SQLite.CodeFirst/SqliteDropCreateDatabaseAlways.cs
+++ b/SQLite.CodeFirst/DbInitializers/SqliteDropCreateDatabaseAlways.cs
@@ -30,8 +30,8 @@ public override void InitializeDatabase(TContext context)
         {
             string databseFilePath = GetDatabasePathFromContext(context);
 
-            bool dbExists = File.Exists(databseFilePath);
-            if (dbExists)
+            bool exists = File.Exists(databseFilePath);
+            if (exists)
             {
                 File.Delete(databseFilePath);
             }
diff --git a/SQLite.CodeFirst/DbInitializers/SqliteDropCreateDatabaseWhenModelChanges.cs b/SQLite.CodeFirst/DbInitializers/SqliteDropCreateDatabaseWhenModelChanges.cs
new file mode 100644
index 0000000..123ccc6
--- /dev/null
+++ b/SQLite.CodeFirst/DbInitializers/SqliteDropCreateDatabaseWhenModelChanges.cs
@@ -0,0 +1,164 @@
+using System;
+using System.Collections.Generic;
+using System.Data.Common;
+using System.Data.Entity;
+using System.Data.Entity.Infrastructure;
+using System.IO;
+using System.Linq;
+using SQLite.CodeFirst.Utility;
+
+namespace SQLite.CodeFirst
+{
+    /// <summary>
+    /// An implementation of <see cref="IDatabaseInitializer{TContext}"/> that will always recreate and optionally re-seed the 
+    /// database the first time that a context is used in the app domain or if the model has changed. 
+    /// To seed the database, create a derived class and override the Seed method.
+    /// <remarks>
+    /// To detect model changes a new table (implementation of <see cref="IHistory"/>) is added to the database.
+    /// There is one record in this table which holds the hash of the SQL-statement which was generated from the model
+    /// executed to create the database. When initializing the database the initializer checks if the hash of the SQL-statement for the
+    /// model is still the same as the hash in the database.  If you use this initializer on a existing database, this initializer 
+    /// will interpret this as model change because of the new <see cref="IHistory"/> table.
+    /// Notice that a database can be used by more than one context. Therefore the name of the context is saved as a part of the history record.
+    /// </remarks>
+    /// </summary>
+    /// <typeparam name="TContext">The type of the context.</typeparam>
+    public class SqliteDropCreateDatabaseWhenModelChanges<TContext> : SqliteInitializerBase<TContext>
+        where TContext : DbContext
+    {
+        private readonly Type historyEntityType;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SqliteDropCreateDatabaseWhenModelChanges{TContext}"/> class.
+        /// </summary>
+        /// <param name="modelBuilder">The model builder.</param>
+        public SqliteDropCreateDatabaseWhenModelChanges(DbModelBuilder modelBuilder)
+            : base(modelBuilder)
+        {
+            historyEntityType = typeof(History);
+            ConfigureHistoryEntity();
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SqliteDropCreateDatabaseWhenModelChanges{TContext}"/> class.
+        /// </summary>
+        /// <param name="modelBuilder">The model builder.</param>
+        /// <param name="historyEntityType">Type of the history entity (must implement <see cref="IHistory"/> and provide an parameterless constructor).</param>
+        public SqliteDropCreateDatabaseWhenModelChanges(DbModelBuilder modelBuilder, Type historyEntityType)
+            : base(modelBuilder)
+        {
+            this.historyEntityType = historyEntityType;
+            ConfigureHistoryEntity();
+        }
+
+
+        protected void ConfigureHistoryEntity()
+        {
+            HistoryEntityTypeValidator.EnsureValidType(historyEntityType);
+            ModelBuilder.RegisterEntityType(historyEntityType);
+        }
+
+        /// <summary>
+        /// Initialize the database for the given context.
+        /// Generates the SQLite-DDL from the model and executs it against the database.
+        /// After that the <see cref="Seed" /> method is executed.
+        /// All actions are be executed in transactions.
+        /// </summary>
+        /// <param name="context">The context.</param>
+        public override void InitializeDatabase(TContext context)
+        {
+            string databseFilePath = GetDatabasePathFromContext(context);
+
+            bool dbExists = File.Exists(databseFilePath);
+            if (dbExists)
+            {
+                if (IsSameModel(context))
+                {
+                    return;
+                }
+
+                DeleteDatabase(context, databseFilePath);
+                base.InitializeDatabase(context);
+                SaveHistory(context);
+            }
+            else
+            {
+                base.InitializeDatabase(context);
+                SaveHistory(context);
+            }
+        }
+
+        private static void DeleteDatabase(TContext context, string databseFilePath)
+        {
+            context.Database.Connection.Close();
+            GC.Collect();
+            GC.WaitForPendingFinalizers();
+            File.Delete(databseFilePath);
+        }
+
+        private void SaveHistory(TContext context)
+        {
+            var hash = GetHashFromModel(context.Database.Connection);
+            var history = GetHistoryRecord(context);
+            EntityState entityState;
+            if (history == null)
+            {
+                history = (IHistory)Activator.CreateInstance(historyEntityType);
+                entityState = EntityState.Added;
+            }
+            else
+            {
+                entityState = EntityState.Modified;
+            }
+
+            history.Context = context.GetType().FullName;
+            history.Hash = hash;
+            history.CreateDate = DateTime.UtcNow;
+
+            context.Set(historyEntityType).Attach(history);
+            context.Entry(history).State = entityState;
+            context.SaveChanges();
+        }
+
+        private bool IsSameModel(TContext context)
+        {
+
+            var hash = GetHashFromModel(context.Database.Connection);
+
+            try
+            {
+                var history = GetHistoryRecord(context);
+                return history?.Hash == hash;
+            }
+            catch (Exception)
+            {
+                // This happens if the history table does not exist.
+                // So it covers also the case with a null byte file (see SqliteCreateDatabaseIfNotExists).
+                return false;
+            }
+        }
+
+        private IHistory GetHistoryRecord(TContext context)
+        {
+            // Yes, it seams to be complicated but it has to be done this way
+            // in order to be supported by .NET 4.0.
+            DbQuery dbQuery = context.Set(historyEntityType).AsNoTracking();
+            IEnumerable<IHistory> records = Enumerable.Cast<IHistory>(dbQuery);
+            return records.SingleOrDefault();
+        }
+
+        private string GetHashFromModel(DbConnection connection)
+        {
+            var sql = GetSqlFromModel(connection);
+            string hash = HashCreator.CreateHash(sql);
+            return hash;
+        }
+
+        private string GetSqlFromModel(DbConnection connection)
+        {
+            var model = ModelBuilder.Build(connection);
+            var sqliteSqlGenerator = new SqliteSqlGenerator();
+            return sqliteSqlGenerator.Generate(model.StoreModel);
+        }
+    }
+}
diff --git a/SQLite.CodeFirst/SqliteInitializerBase.cs b/SQLite.CodeFirst/DbInitializers/SqliteInitializerBase.cs
similarity index 86%
rename from SQLite.CodeFirst/SqliteInitializerBase.cs
rename to SQLite.CodeFirst/DbInitializers/SqliteInitializerBase.cs
index 25b571f..b063412 100644
--- a/SQLite.CodeFirst/SqliteInitializerBase.cs
+++ b/SQLite.CodeFirst/DbInitializers/SqliteInitializerBase.cs
@@ -3,6 +3,7 @@
 using System.Data.Entity.ModelConfiguration.Conventions;
 using SQLite.CodeFirst.Convention;
 using System.IO;
+using SQLite.CodeFirst.Utility;
 
 namespace SQLite.CodeFirst
 {
@@ -10,17 +11,17 @@ namespace SQLite.CodeFirst
     /// An basic implementation of the <see cref="IDatabaseInitializer{TContext}"/> interface.
     /// This class provides common logic which can be used when writing an Sqlite-Initializer.
     /// The logic provided is: 
-    ///   1. Remove/Add specific Conventions 
+    ///   1. Remove/Add specific conventions 
     ///   2. Get the path to the database file  
-    ///   3. Create a new SQLite-Database from the model (Code First)
+    ///   3. Create a new SQLite-database from the model (Code First)
     ///   4. Seed data to the new created database
-    /// The following implementations are provided: <see cref="T:SQLite.CodeFirst.SqliteCreateDatabaseIfNotExists`1"/>,  <see cref="T:SQlite.CodeFirst.SqliteDropCreateDatabaseAlways`1"/>.
+    /// The following implementations are provided: <see cref="T:SQLite.CodeFirst.SqliteCreateDatabaseIfNotExists`1"/>, <see cref="T:SQlite.CodeFirst.SqliteDropCreateDatabaseAlways`1"/>.
     /// </summary>
     /// <typeparam name="TContext">The type of the context.</typeparam>
     public abstract class SqliteInitializerBase<TContext> : IDatabaseInitializer<TContext>
         where TContext : DbContext
     {
-        private readonly DbModelBuilder modelBuilder;
+        protected readonly DbModelBuilder ModelBuilder;
 
         protected SqliteInitializerBase(DbModelBuilder modelBuilder)
         {
@@ -29,7 +30,7 @@ protected SqliteInitializerBase(DbModelBuilder modelBuilder)
                 throw new ArgumentNullException("modelBuilder");
             }
 
-            this.modelBuilder = modelBuilder;
+            ModelBuilder = modelBuilder;
 
             // This convention will crash the SQLite Provider before "InitializeDatabase" gets called.
             // See https://github.com/msallin/SQLiteCodeFirst/issues/7 for details.
@@ -44,7 +45,7 @@ protected SqliteInitializerBase(DbModelBuilder modelBuilder)
                 // The own convention will rename the automatically created indicies by using the correct scheme.
                 modelBuilder.Conventions.AddAfter<ForeignKeyIndexConvention>(new SqliteForeignKeyIndexConvention());
             }
-            catch (InvalidOperationException exception)
+            catch (InvalidOperationException)
             {
                 // Ignore it.
             }
@@ -59,7 +60,7 @@ protected SqliteInitializerBase(DbModelBuilder modelBuilder)
         /// <param name="context">The context. </param>
         public virtual void InitializeDatabase(TContext context)
         {
-            var model = modelBuilder.Build(context.Database.Connection);
+            var model = ModelBuilder.Build(context.Database.Connection);
 
             var dbFile = GetDatabasePathFromContext(context);
             var dbFileInfo = new FileInfo(dbFile);
@@ -69,8 +70,8 @@ public virtual void InitializeDatabase(TContext context)
             {
                 try
                 {
-                    var sqliteDatabaseCreator = new SqliteDatabaseCreator(context.Database, model);
-                    sqliteDatabaseCreator.Create();
+                    var sqliteDatabaseCreator = new SqliteDatabaseCreator();
+                    sqliteDatabaseCreator.Create(context.Database, model);
                     transaction.Commit();
                 }
                 catch (Exception)
@@ -110,7 +111,7 @@ protected virtual void Seed(TContext context) { }
         /// <returns>The full path to the SQLite database file.</returns>
         protected string GetDatabasePathFromContext(TContext context)
         {
-            return SqliteConnectionStringParser.GetDataSource(context.Database.Connection.ConnectionString);
+            return ConnectionStringParser.GetDataSource(context.Database.Connection.ConnectionString);
         }
     }
 }
\ No newline at end of file
diff --git a/SQLite.CodeFirst/Entities/History.cs b/SQLite.CodeFirst/Entities/History.cs
new file mode 100644
index 0000000..5238aee
--- /dev/null
+++ b/SQLite.CodeFirst/Entities/History.cs
@@ -0,0 +1,56 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace SQLite.CodeFirst
+{
+    /// <summary>
+    /// Represents the database table "history" which is used to store the necessary information
+    /// to detect if the model has changed.
+    /// </summary>
+    [Table(nameof(History) + "_" + TableNamePostfix)]
+    public class History : IHistory
+    {
+        /// <summary>
+        /// The postfix which is appended to the history table name 
+        /// to ensure that this table name is unique.
+        /// </summary>
+        public const string TableNamePostfix = "82c009b41631-48579635f1ff64eb62d9";
+
+        /// <summary>
+        /// Gets or sets the identifier of the record.
+        /// <remarks>Is automatilcally generated by the database.</remarks>
+        /// </summary>
+        /// <value>
+        /// The identifier.
+        /// </value>
+        [Key]
+        public int Id { get; set; }
+
+        /// <summary>
+        /// Gets or sets the hash which represents the current database structure/state.
+        /// </summary>
+        /// <value>
+        /// The hash.
+        /// </value>
+        [Required]
+        public string Hash { get; set; }
+
+        /// <summary>
+        /// Gets or sets the key of the DbContext to which this record belongs.
+        /// </summary>
+        /// <value>
+        /// The context key.
+        /// </value>
+        public string Context { get; set; }
+
+        /// <summary>
+        /// Gets or sets the create date of the record.
+        /// </summary>
+        /// <value>
+        /// The create date.
+        /// </value>
+        [Required]
+        public DateTime CreateDate { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/SQLite.CodeFirst/Entities/IHistory.cs b/SQLite.CodeFirst/Entities/IHistory.cs
new file mode 100644
index 0000000..cbaf2e3
--- /dev/null
+++ b/SQLite.CodeFirst/Entities/IHistory.cs
@@ -0,0 +1,12 @@
+using System;
+
+namespace SQLite.CodeFirst
+{
+    public interface IHistory
+    {
+        int Id { get; set; }
+        string Hash { get; set; }
+        string Context { get; set; }
+        DateTime CreateDate { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/SQLite.CodeFirst/IDatabaseCreator.cs b/SQLite.CodeFirst/IDatabaseCreator.cs
new file mode 100644
index 0000000..aef2a47
--- /dev/null
+++ b/SQLite.CodeFirst/IDatabaseCreator.cs
@@ -0,0 +1,10 @@
+using System.Data.Entity;
+using System.Data.Entity.Infrastructure;
+
+namespace SQLite.CodeFirst
+{
+    public interface IDatabaseCreator
+    {
+        void Create(Database db, DbModel model);
+    }
+}
\ No newline at end of file
diff --git a/SQLite.CodeFirst/ISqliteSqlGenerator.cs b/SQLite.CodeFirst/ISqliteSqlGenerator.cs
new file mode 100644
index 0000000..c57c0d2
--- /dev/null
+++ b/SQLite.CodeFirst/ISqliteSqlGenerator.cs
@@ -0,0 +1,9 @@
+using System.Data.Entity.Core.Metadata.Edm;
+
+namespace SQLite.CodeFirst
+{
+    public interface ISqlGenerator
+    {
+        string Generate(EdmModel storeModel);
+    }
+}
\ No newline at end of file
diff --git a/SQLite.CodeFirst/Builder/ColumnStatementCollectionBuilder.cs b/SQLite.CodeFirst/Internal/Builder/ColumnStatementCollectionBuilder.cs
similarity index 100%
rename from SQLite.CodeFirst/Builder/ColumnStatementCollectionBuilder.cs
rename to SQLite.CodeFirst/Internal/Builder/ColumnStatementCollectionBuilder.cs
diff --git a/SQLite.CodeFirst/Builder/CreateDatabaseStatementBuilder.cs b/SQLite.CodeFirst/Internal/Builder/CreateDatabaseStatementBuilder.cs
similarity index 100%
rename from SQLite.CodeFirst/Builder/CreateDatabaseStatementBuilder.cs
rename to SQLite.CodeFirst/Internal/Builder/CreateDatabaseStatementBuilder.cs
diff --git a/SQLite.CodeFirst/Builder/CreateIndexStatementBuilder.cs b/SQLite.CodeFirst/Internal/Builder/CreateIndexStatementBuilder.cs
similarity index 100%
rename from SQLite.CodeFirst/Builder/CreateIndexStatementBuilder.cs
rename to SQLite.CodeFirst/Internal/Builder/CreateIndexStatementBuilder.cs
diff --git a/SQLite.CodeFirst/Builder/CreateTableStatementBuilder.cs b/SQLite.CodeFirst/Internal/Builder/CreateTableStatementBuilder.cs
similarity index 100%
rename from SQLite.CodeFirst/Builder/CreateTableStatementBuilder.cs
rename to SQLite.CodeFirst/Internal/Builder/CreateTableStatementBuilder.cs
diff --git a/SQLite.CodeFirst/Builder/ForeignKeyStatementBuilder.cs b/SQLite.CodeFirst/Internal/Builder/ForeignKeyStatementBuilder.cs
similarity index 100%
rename from SQLite.CodeFirst/Builder/ForeignKeyStatementBuilder.cs
rename to SQLite.CodeFirst/Internal/Builder/ForeignKeyStatementBuilder.cs
diff --git a/SQLite.CodeFirst/Builder/IStatementBuilder.cs b/SQLite.CodeFirst/Internal/Builder/IStatementBuilder.cs
similarity index 74%
rename from SQLite.CodeFirst/Builder/IStatementBuilder.cs
rename to SQLite.CodeFirst/Internal/Builder/IStatementBuilder.cs
index 8d52cb9..8c37eda 100644
--- a/SQLite.CodeFirst/Builder/IStatementBuilder.cs
+++ b/SQLite.CodeFirst/Internal/Builder/IStatementBuilder.cs
@@ -2,7 +2,7 @@
 
 namespace SQLite.CodeFirst.Builder
 {
-    public interface IStatementBuilder<out TStatement>
+    internal interface IStatementBuilder<out TStatement>
         where TStatement : IStatement
     {
         TStatement BuildStatement();
diff --git a/SQLite.CodeFirst/Builder/NameCreators/IndexNameCreator.cs b/SQLite.CodeFirst/Internal/Builder/NameCreators/IndexNameCreator.cs
similarity index 100%
rename from SQLite.CodeFirst/Builder/NameCreators/IndexNameCreator.cs
rename to SQLite.CodeFirst/Internal/Builder/NameCreators/IndexNameCreator.cs
diff --git a/SQLite.CodeFirst/Builder/NameCreators/SpecialChars.cs b/SQLite.CodeFirst/Internal/Builder/NameCreators/SpecialChars.cs
similarity index 100%
rename from SQLite.CodeFirst/Builder/NameCreators/SpecialChars.cs
rename to SQLite.CodeFirst/Internal/Builder/NameCreators/SpecialChars.cs
diff --git a/SQLite.CodeFirst/Builder/NameCreators/TableNameCreator.cs b/SQLite.CodeFirst/Internal/Builder/NameCreators/TableNameCreator.cs
similarity index 100%
rename from SQLite.CodeFirst/Builder/NameCreators/TableNameCreator.cs
rename to SQLite.CodeFirst/Internal/Builder/NameCreators/TableNameCreator.cs
diff --git a/SQLite.CodeFirst/Builder/PrimaryKeyStatementBuilder.cs b/SQLite.CodeFirst/Internal/Builder/PrimaryKeyStatementBuilder.cs
similarity index 100%
rename from SQLite.CodeFirst/Builder/PrimaryKeyStatementBuilder.cs
rename to SQLite.CodeFirst/Internal/Builder/PrimaryKeyStatementBuilder.cs
diff --git a/SQLite.CodeFirst/Convention/SqliteForeignKeyIndexConvention.cs b/SQLite.CodeFirst/Internal/Convention/SqliteForeignKeyIndexConvention.cs
similarity index 97%
rename from SQLite.CodeFirst/Convention/SqliteForeignKeyIndexConvention.cs
rename to SQLite.CodeFirst/Internal/Convention/SqliteForeignKeyIndexConvention.cs
index 6b6038a..08681af 100644
--- a/SQLite.CodeFirst/Convention/SqliteForeignKeyIndexConvention.cs
+++ b/SQLite.CodeFirst/Internal/Convention/SqliteForeignKeyIndexConvention.cs
@@ -17,7 +17,7 @@ namespace SQLite.CodeFirst.Convention
     /// This is necessary because in SQLite an index-name must be unique.
     /// Must be added right after the <see cref="ForeignKeyIndexConvention"/>-Convention.
     /// </summary>
-    public class SqliteForeignKeyIndexConvention : IStoreModelConvention<AssociationType>
+    internal class SqliteForeignKeyIndexConvention : IStoreModelConvention<AssociationType>
     {
         private const string IndexAnnotationName = "http://schemas.microsoft.com/ado/2013/11/edm/customannotation:Index";
 
diff --git a/SQLite.CodeFirst/Extensions/EntityTypeExtension.cs b/SQLite.CodeFirst/Internal/Extensions/EntityTypeExtension.cs
similarity index 100%
rename from SQLite.CodeFirst/Extensions/EntityTypeExtension.cs
rename to SQLite.CodeFirst/Internal/Extensions/EntityTypeExtension.cs
diff --git a/SQLite.CodeFirst/Statement/ColumnConstraint/ColumnConstraintCollection.cs b/SQLite.CodeFirst/Internal/Statement/ColumnConstraint/ColumnConstraintCollection.cs
similarity index 100%
rename from SQLite.CodeFirst/Statement/ColumnConstraint/ColumnConstraintCollection.cs
rename to SQLite.CodeFirst/Internal/Statement/ColumnConstraint/ColumnConstraintCollection.cs
diff --git a/SQLite.CodeFirst/Statement/ColumnConstraint/IColumnConstraint.cs b/SQLite.CodeFirst/Internal/Statement/ColumnConstraint/IColumnConstraint.cs
similarity index 100%
rename from SQLite.CodeFirst/Statement/ColumnConstraint/IColumnConstraint.cs
rename to SQLite.CodeFirst/Internal/Statement/ColumnConstraint/IColumnConstraint.cs
diff --git a/SQLite.CodeFirst/Statement/ColumnConstraint/IColumnConstraintCollection.cs b/SQLite.CodeFirst/Internal/Statement/ColumnConstraint/IColumnConstraintCollection.cs
similarity index 100%
rename from SQLite.CodeFirst/Statement/ColumnConstraint/IColumnConstraintCollection.cs
rename to SQLite.CodeFirst/Internal/Statement/ColumnConstraint/IColumnConstraintCollection.cs
diff --git a/SQLite.CodeFirst/Statement/ColumnConstraint/MaxLengthConstraint.cs b/SQLite.CodeFirst/Internal/Statement/ColumnConstraint/MaxLengthConstraint.cs
similarity index 100%
rename from SQLite.CodeFirst/Statement/ColumnConstraint/MaxLengthConstraint.cs
rename to SQLite.CodeFirst/Internal/Statement/ColumnConstraint/MaxLengthConstraint.cs
diff --git a/SQLite.CodeFirst/Statement/ColumnConstraint/NotNullConstraint.cs b/SQLite.CodeFirst/Internal/Statement/ColumnConstraint/NotNullConstraint.cs
similarity index 100%
rename from SQLite.CodeFirst/Statement/ColumnConstraint/NotNullConstraint.cs
rename to SQLite.CodeFirst/Internal/Statement/ColumnConstraint/NotNullConstraint.cs
diff --git a/SQLite.CodeFirst/Statement/ColumnStatement.cs b/SQLite.CodeFirst/Internal/Statement/ColumnStatement.cs
similarity index 100%
rename from SQLite.CodeFirst/Statement/ColumnStatement.cs
rename to SQLite.CodeFirst/Internal/Statement/ColumnStatement.cs
diff --git a/SQLite.CodeFirst/Statement/ColumnStatementCollection.cs b/SQLite.CodeFirst/Internal/Statement/ColumnStatementCollection.cs
similarity index 100%
rename from SQLite.CodeFirst/Statement/ColumnStatementCollection.cs
rename to SQLite.CodeFirst/Internal/Statement/ColumnStatementCollection.cs
diff --git a/SQLite.CodeFirst/Statement/CreateDatabaseStatement.cs b/SQLite.CodeFirst/Internal/Statement/CreateDatabaseStatement.cs
similarity index 100%
rename from SQLite.CodeFirst/Statement/CreateDatabaseStatement.cs
rename to SQLite.CodeFirst/Internal/Statement/CreateDatabaseStatement.cs
diff --git a/SQLite.CodeFirst/Statement/CreateIndexStatement.cs b/SQLite.CodeFirst/Internal/Statement/CreateIndexStatement.cs
similarity index 100%
rename from SQLite.CodeFirst/Statement/CreateIndexStatement.cs
rename to SQLite.CodeFirst/Internal/Statement/CreateIndexStatement.cs
diff --git a/SQLite.CodeFirst/Statement/CreateIndexStatementCollection.cs b/SQLite.CodeFirst/Internal/Statement/CreateIndexStatementCollection.cs
similarity index 100%
rename from SQLite.CodeFirst/Statement/CreateIndexStatementCollection.cs
rename to SQLite.CodeFirst/Internal/Statement/CreateIndexStatementCollection.cs
diff --git a/SQLite.CodeFirst/Statement/CreateTableStatement.cs b/SQLite.CodeFirst/Internal/Statement/CreateTableStatement.cs
similarity index 100%
rename from SQLite.CodeFirst/Statement/CreateTableStatement.cs
rename to SQLite.CodeFirst/Internal/Statement/CreateTableStatement.cs
diff --git a/SQLite.CodeFirst/Statement/ForeignKeyStatement.cs b/SQLite.CodeFirst/Internal/Statement/ForeignKeyStatement.cs
similarity index 100%
rename from SQLite.CodeFirst/Statement/ForeignKeyStatement.cs
rename to SQLite.CodeFirst/Internal/Statement/ForeignKeyStatement.cs
diff --git a/SQLite.CodeFirst/Statement/IStatement.cs b/SQLite.CodeFirst/Internal/Statement/IStatement.cs
similarity index 100%
rename from SQLite.CodeFirst/Statement/IStatement.cs
rename to SQLite.CodeFirst/Internal/Statement/IStatement.cs
diff --git a/SQLite.CodeFirst/Statement/IStatementCollection.cs b/SQLite.CodeFirst/Internal/Statement/IStatementCollection.cs
similarity index 100%
rename from SQLite.CodeFirst/Statement/IStatementCollection.cs
rename to SQLite.CodeFirst/Internal/Statement/IStatementCollection.cs
diff --git a/SQLite.CodeFirst/Statement/PrimaryKeyStatement.cs b/SQLite.CodeFirst/Internal/Statement/PrimaryKeyStatement.cs
similarity index 100%
rename from SQLite.CodeFirst/Statement/PrimaryKeyStatement.cs
rename to SQLite.CodeFirst/Internal/Statement/PrimaryKeyStatement.cs
diff --git a/SQLite.CodeFirst/Utility/AssociationTypeWrapper.cs b/SQLite.CodeFirst/Internal/Utility/AssociationTypeWrapper.cs
similarity index 100%
rename from SQLite.CodeFirst/Utility/AssociationTypeWrapper.cs
rename to SQLite.CodeFirst/Internal/Utility/AssociationTypeWrapper.cs
diff --git a/SQLite.CodeFirst/SqliteConnectionStringParser.cs b/SQLite.CodeFirst/Internal/Utility/ConnectionStringParser.cs
similarity index 91%
rename from SQLite.CodeFirst/SqliteConnectionStringParser.cs
rename to SQLite.CodeFirst/Internal/Utility/ConnectionStringParser.cs
index 8d7d12d..b87f8b3 100644
--- a/SQLite.CodeFirst/SqliteConnectionStringParser.cs
+++ b/SQLite.CodeFirst/Internal/Utility/ConnectionStringParser.cs
@@ -2,9 +2,9 @@
 using System.Collections.Generic;
 using System.Globalization;
 
-namespace SQLite.CodeFirst
+namespace SQLite.CodeFirst.Utility
 {
-    internal static class SqliteConnectionStringParser
+    internal static class ConnectionStringParser
     {
         private const string DataDirectoryToken = "|datadirectory|";
         private const char KeyValuePairSeperator = ';';
@@ -12,7 +12,7 @@ internal static class SqliteConnectionStringParser
         private const int KeyPosition = 0;
         private const int ValuePosition = 1;
 
-        public static IDictionary<string, string> ParseSqliteConnectionString(string connectionString)
+        public static IDictionary<string, string> ParseConnectionString(string connectionString)
         {
             connectionString = connectionString.Trim();
             string[] keyValuePairs = connectionString.Split(KeyValuePairSeperator);
@@ -32,7 +32,7 @@ public static IDictionary<string, string> ParseSqliteConnectionString(string con
 
         public static string GetDataSource(string connectionString)
         {
-            var path = ExpandDataDirectory(ParseSqliteConnectionString(connectionString)["data source"]);
+            var path = ExpandDataDirectory(ParseConnectionString(connectionString)["data source"]);
             // remove quotation mark if exists
             path = path.Trim('"');
             return path;
diff --git a/SQLite.CodeFirst/Internal/Utility/HashCreator.cs b/SQLite.CodeFirst/Internal/Utility/HashCreator.cs
new file mode 100644
index 0000000..3b4f366
--- /dev/null
+++ b/SQLite.CodeFirst/Internal/Utility/HashCreator.cs
@@ -0,0 +1,18 @@
+using System;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace SQLite.CodeFirst.Utility
+{
+    internal static class HashCreator
+    {
+        public static string CreateHash(string data)
+        {
+            byte[] dataBytes = Encoding.ASCII.GetBytes(data);
+            SHA512 sha512 = new SHA512Managed();
+            byte[] hashBytes = sha512.ComputeHash(dataBytes);
+            string hash = Convert.ToBase64String(hashBytes);
+            return hash;
+        }
+    }
+}
diff --git a/SQLite.CodeFirst/Internal/Utility/HistoryEntityTypeValidator.cs b/SQLite.CodeFirst/Internal/Utility/HistoryEntityTypeValidator.cs
new file mode 100644
index 0000000..459e2ee
--- /dev/null
+++ b/SQLite.CodeFirst/Internal/Utility/HistoryEntityTypeValidator.cs
@@ -0,0 +1,19 @@
+using System;
+
+namespace SQLite.CodeFirst.Utility
+{
+    internal class HistoryEntityTypeValidator
+    {
+        public static void EnsureValidType(Type historyEntityType)
+        {
+            if (!typeof(IHistory).IsAssignableFrom(historyEntityType))
+            {
+                throw new InvalidOperationException("The Type " + historyEntityType.Name + " does not implement the IHistory interface.");
+            }
+            if (historyEntityType.GetConstructor(Type.EmptyTypes) == null)
+            {
+                throw new InvalidOperationException("The Type " + historyEntityType.Name + " does not provide an parameterless constructor.");
+            }
+        }
+    }
+}
diff --git a/SQLite.CodeFirst/SQLite.CodeFirst.csproj b/SQLite.CodeFirst/SQLite.CodeFirst.csproj
index 0ce1922..92526ab 100644
--- a/SQLite.CodeFirst/SQLite.CodeFirst.csproj
+++ b/SQLite.CodeFirst/SQLite.CodeFirst.csproj
@@ -75,6 +75,7 @@
   </ItemGroup>
   <ItemGroup>
     <Reference Include="System" />
+    <Reference Include="System.ComponentModel.DataAnnotations" />
     <Reference Include="System.Core" />
     <Reference Include="System.Data" />
   </ItemGroup>
@@ -85,40 +86,48 @@
     <Compile Include="..\Shared\AssemblyVersionInfo.cs">
       <Link>Properties\AssemblyVersionInfo.cs</Link>
     </Compile>
-    <Compile Include="Builder\NameCreators\IndexNameCreator.cs" />
-    <Compile Include="Builder\NameCreators\SpecialChars.cs" />
-    <Compile Include="Statement\ColumnConstraint\IColumnConstraintCollection.cs" />
-    <Compile Include="Statement\IStatementCollection.cs" />
-    <Compile Include="Utility\AssociationTypeWrapper.cs" />
-    <Compile Include="Builder\ColumnStatementCollectionBuilder.cs" />
-    <Compile Include="Builder\CreateIndexStatementBuilder.cs" />
-    <Compile Include="Builder\ForeignKeyStatementBuilder.cs" />
-    <Compile Include="Builder\CreateDatabaseStatementBuilder.cs" />
-    <Compile Include="Builder\PrimaryKeyStatementBuilder.cs" />
-    <Compile Include="Convention\SqliteForeignKeyIndexConvention.cs" />
-    <Compile Include="Extensions\EntityTypeExtension.cs" />
-    <Compile Include="SqliteCreateDatabaseIfNotExists.cs" />
-    <Compile Include="SqliteDropCreateDatabaseAlways.cs" />
-    <Compile Include="Statement\ColumnConstraint\MaxLengthConstraint.cs" />
-    <Compile Include="Statement\CreateIndexStatement.cs" />
-    <Compile Include="Statement\CreateIndexStatementCollection.cs" />
-    <Compile Include="Statement\PrimaryKeyStatement.cs" />
+    <Compile Include="Entities\IHistory.cs" />
+    <Compile Include="Internal\Builder\NameCreators\IndexNameCreator.cs" />
+    <Compile Include="Internal\Builder\NameCreators\SpecialChars.cs" />
+    <Compile Include="IDatabaseCreator.cs" />
+    <Compile Include="Internal\Utility\HashCreator.cs" />
+    <Compile Include="Internal\Utility\HistoryEntityTypeValidator.cs" />
+    <Compile Include="ISqliteSqlGenerator.cs" />
+    <Compile Include="DbInitializers\SqliteDropCreateDatabaseWhenModelChanges.cs" />
+    <Compile Include="Entities\History.cs" />
+    <Compile Include="SqliteSqlGenerator.cs" />
+    <Compile Include="Internal\Statement\ColumnConstraint\IColumnConstraintCollection.cs" />
+    <Compile Include="Internal\Statement\IStatementCollection.cs" />
+    <Compile Include="Internal\Utility\AssociationTypeWrapper.cs" />
+    <Compile Include="Internal\Builder\ColumnStatementCollectionBuilder.cs" />
+    <Compile Include="Internal\Builder\CreateIndexStatementBuilder.cs" />
+    <Compile Include="Internal\Builder\ForeignKeyStatementBuilder.cs" />
+    <Compile Include="Internal\Builder\CreateDatabaseStatementBuilder.cs" />
+    <Compile Include="Internal\Builder\PrimaryKeyStatementBuilder.cs" />
+    <Compile Include="Internal\Convention\SqliteForeignKeyIndexConvention.cs" />
+    <Compile Include="Internal\Extensions\EntityTypeExtension.cs" />
+    <Compile Include="DbInitializers\SqliteCreateDatabaseIfNotExists.cs" />
+    <Compile Include="DbInitializers\SqliteDropCreateDatabaseAlways.cs" />
+    <Compile Include="Internal\Statement\ColumnConstraint\MaxLengthConstraint.cs" />
+    <Compile Include="Internal\Statement\CreateIndexStatement.cs" />
+    <Compile Include="Internal\Statement\CreateIndexStatementCollection.cs" />
+    <Compile Include="Internal\Statement\PrimaryKeyStatement.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="SqliteConnectionStringParser.cs" />
-    <Compile Include="SqliteInitializerBase.cs" />
-    <Compile Include="Builder\IStatementBuilder.cs" />
+    <Compile Include="Internal\Utility\ConnectionStringParser.cs" />
+    <Compile Include="DbInitializers\SqliteInitializerBase.cs" />
+    <Compile Include="Internal\Builder\IStatementBuilder.cs" />
     <Compile Include="SqliteDatabaseCreator.cs" />
-    <Compile Include="Statement\ColumnConstraint\ColumnConstraintCollection.cs" />
-    <Compile Include="Statement\ForeignKeyStatement.cs" />
-    <Compile Include="Statement\ColumnConstraint\IColumnConstraint.cs" />
-    <Compile Include="Statement\ColumnConstraint\NotNullConstraint.cs" />
-    <Compile Include="Statement\ColumnStatementCollection.cs" />
-    <Compile Include="Statement\ColumnStatement.cs" />
-    <Compile Include="Statement\CreateDatabaseStatement.cs" />
-    <Compile Include="Statement\CreateTableStatement.cs" />
-    <Compile Include="Statement\IStatement.cs" />
-    <Compile Include="Builder\CreateTableStatementBuilder.cs" />
-    <Compile Include="Builder\NameCreators\TableNameCreator.cs" />
+    <Compile Include="Internal\Statement\ColumnConstraint\ColumnConstraintCollection.cs" />
+    <Compile Include="Internal\Statement\ForeignKeyStatement.cs" />
+    <Compile Include="Internal\Statement\ColumnConstraint\IColumnConstraint.cs" />
+    <Compile Include="Internal\Statement\ColumnConstraint\NotNullConstraint.cs" />
+    <Compile Include="Internal\Statement\ColumnStatementCollection.cs" />
+    <Compile Include="Internal\Statement\ColumnStatement.cs" />
+    <Compile Include="Internal\Statement\CreateDatabaseStatement.cs" />
+    <Compile Include="Internal\Statement\CreateTableStatement.cs" />
+    <Compile Include="Internal\Statement\IStatement.cs" />
+    <Compile Include="Internal\Builder\CreateTableStatementBuilder.cs" />
+    <Compile Include="Internal\Builder\NameCreators\TableNameCreator.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />
@@ -131,8 +140,6 @@
       <ErrorText>This project references NuGet package(s) that are missing on this computer. Enable NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
     </PropertyGroup>
     <Error Condition="!Exists('$(SolutionDir)\.nuget\NuGet.targets')" Text="$([System.String]::Format('$(ErrorText)', '$(SolutionDir)\.nuget\NuGet.targets'))" />
-    <Error Condition="!Exists('..\packages\System.Data.SQLite.Core.1.0.97.0\build\net40\System.Data.SQLite.Core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\System.Data.SQLite.Core.1.0.97.0\build\net40\System.Data.SQLite.Core.targets'))" />
   </Target>
   <Import Project="$(SolutionDir)\.nuget\NuGet.targets" Condition="Exists('$(SolutionDir)\.nuget\NuGet.targets')" />
-  <Import Project="..\packages\System.Data.SQLite.Core.1.0.97.0\build\net40\System.Data.SQLite.Core.targets" Condition="Exists('..\packages\System.Data.SQLite.Core.1.0.97.0\build\net40\System.Data.SQLite.Core.targets')" />
 </Project>
\ No newline at end of file
diff --git a/SQLite.CodeFirst/SQLite.CodeFirst.csproj.DotSettings b/SQLite.CodeFirst/SQLite.CodeFirst.csproj.DotSettings
new file mode 100644
index 0000000..588c632
--- /dev/null
+++ b/SQLite.CodeFirst/SQLite.CodeFirst.csproj.DotSettings
@@ -0,0 +1,8 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=dbinitializers/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=entities/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=internal/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=public/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=public_005Cdbinitializers/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=public_005Centities/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=sqlitedatabaseinitializers/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
\ No newline at end of file
diff --git a/SQLite.CodeFirst/SQLite.CodeFirst.csproj.nuspec b/SQLite.CodeFirst/SQLite.CodeFirst.csproj.nuspec
index f34f826..6236557 100644
--- a/SQLite.CodeFirst/SQLite.CodeFirst.csproj.nuspec
+++ b/SQLite.CodeFirst/SQLite.CodeFirst.csproj.nuspec
@@ -18,6 +18,7 @@
     </dependencies>
     <frameworkAssemblies>
       <frameworkAssembly assemblyName="System" targetFramework="" />
+      <frameworkAssembly assemblyName="System.ComponentModel.DataAnnotations" targetFramework="" />
       <frameworkAssembly assemblyName="System.Core" targetFramework="" />
       <frameworkAssembly assemblyName="System.Data" targetFramework="" />
     </frameworkAssemblies>
diff --git a/SQLite.CodeFirst/SqliteDatabaseCreator.cs b/SQLite.CodeFirst/SqliteDatabaseCreator.cs
index 11e5d62..2050e0d 100644
--- a/SQLite.CodeFirst/SqliteDatabaseCreator.cs
+++ b/SQLite.CodeFirst/SqliteDatabaseCreator.cs
@@ -1,7 +1,5 @@
 using System.Data.Entity;
 using System.Data.Entity.Infrastructure;
-using SQLite.CodeFirst.Builder;
-using SQLite.CodeFirst.Statement;
 
 namespace SQLite.CodeFirst
 {
@@ -9,31 +7,16 @@ namespace SQLite.CodeFirst
     /// Creates a SQLite-Database based on a Entity Framework <see cref="Database"/> and <see cref="DbModel"/>.
     /// This creator can be used standalone or within an initializer.
     /// </summary>
-    public class SqliteDatabaseCreator
+    public class SqliteDatabaseCreator : IDatabaseCreator
     {
-        private readonly Database db;
-        private readonly DbModel model;
-
-		/// <summary>
-		/// Initializes a new instance of the <see cref="SqliteDatabaseCreator"/> class.
-		/// </summary>
-		/// <param name="db">The database.</param>
-		/// <param name="model">The model.</param>
-		public SqliteDatabaseCreator(Database db, DbModel model)
-        {
-            this.db = db;
-            this.model = model;
-        }
-
         /// <summary>
         /// Creates the SQLite-Database.
         /// </summary>
-        public void Create()
+        public void Create(Database db, DbModel model)
         {
-            IStatementBuilder<CreateDatabaseStatement> statementBuilder = new CreateDatabaseStatementBuilder(model.StoreModel);
-            IStatement statement = statementBuilder.BuildStatement();
-            string sql = statement.CreateStatement();
-            db.ExecuteSqlCommand(sql);
+            var sqliteSqlGenerator = new SqliteSqlGenerator();
+            string sql = sqliteSqlGenerator.Generate(model.StoreModel);
+            db.ExecuteSqlCommand(TransactionalBehavior.EnsureTransaction, sql);
         }
     }
 }
diff --git a/SQLite.CodeFirst/SqliteSqlGenerator.cs b/SQLite.CodeFirst/SqliteSqlGenerator.cs
new file mode 100644
index 0000000..d0f248a
--- /dev/null
+++ b/SQLite.CodeFirst/SqliteSqlGenerator.cs
@@ -0,0 +1,22 @@
+using System.Data.Entity.Core.Metadata.Edm;
+using SQLite.CodeFirst.Builder;
+using SQLite.CodeFirst.Statement;
+
+namespace SQLite.CodeFirst
+{
+    /// <summary>
+    /// Generates the SQL statement to create a database, based on a <see cref="EdmModel"/>.
+    /// </summary>
+    public class SqliteSqlGenerator : ISqlGenerator
+    {
+        /// <summary>
+        /// Generates the SQL statement, based on the <see cref="EdmModel"/>.
+        /// </summary>
+        public string Generate(EdmModel storeModel)
+        {
+            IStatementBuilder<CreateDatabaseStatement> statementBuilder = new CreateDatabaseStatementBuilder(storeModel);
+            IStatement statement = statementBuilder.BuildStatement();
+            return statement.CreateStatement();
+        }
+    }
+}
diff --git a/SQLite.CodeFirst/packages.config b/SQLite.CodeFirst/packages.config
index 57e2eaa..cb3371a 100644
--- a/SQLite.CodeFirst/packages.config
+++ b/SQLite.CodeFirst/packages.config
@@ -1,8 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="EntityFramework" version="6.1.3" targetFramework="net4" userInstalled="true" />
-  <package id="System.Data.SQLite" version="1.0.97.0" targetFramework="net4" userInstalled="true" />
-  <package id="System.Data.SQLite.Core" version="1.0.97.0" targetFramework="net4" userInstalled="true" />
-  <package id="System.Data.SQLite.EF6" version="1.0.97.0" targetFramework="net4" userInstalled="true" />
-  <package id="System.Data.SQLite.Linq" version="1.0.97.0" targetFramework="net4" userInstalled="true" />
 </packages>
\ No newline at end of file
diff --git a/release_appveyor.yml b/release_appveyor.yml
index e7c88b0..6bb2ed5 100644
--- a/release_appveyor.yml
+++ b/release_appveyor.yml
@@ -1,4 +1,4 @@
-version: 1.0.{build}.0
+version: 1.1.{build}.0
 branches:
   only:
   - master