Introduced SqliteDropCreateDatabaseAlways and SqliteCreateDatabaseIfNotExists. Renamed SqliteContextInitializer to SqliteInitializerBase and modified the visibility to internal.

Author: msallin

README.md

@@ -1,7 +1,7 @@
 # SQLite CodeFirst
 Creates a [SQLite Database](https://sqlite.org/) from Code, using [Entity Framework](https://msdn.microsoft.com/en-us/data/ef.aspx) CodeFirst.
 
-This Project ships a `SqliteContextInitializer` which creates a new SQLite Database, based on your model/code.
+This Project ships several `IDbInitializer` which creates a new SQLite Database, based on your model/code.
 I started with the [code](https://gist.github.com/flaub/1968486e1b3f2b9fddaf) from [flaub](https://github.com/flaub). 
 
 Currently the following is supported:
@@ -13,38 +13,38 @@ Currently the following is supported:
 - Auto increment (An int PrimaryKey will automatically be incremented)
 
 I tried to write the code in a extensible way.
-The logic is devided into two main parts. Builder and Statement.
+The logic is divided into two main parts. Builder and Statement.
 The Builder knows how to translate the EdmModel into statements where a statement class creates the SQLite-DDL-Code. 
 The structure of the statements is influenced by the [SQLite Language Specification](https://www.sqlite.org/lang.html).
 You will find an extensive usage of the composite pattern.
 
 ## How to use
-If you want to let the Entity Framework create the database, if it does not exist, just set `SqliteContextInitializer<>` as your `IDbInitializer`.
+If you want to let the Entity Framework create the database, if it does not exist, just set `SqliteDropCreateDatabaseAlways<>` or `SqliteCreateDatabaseIfNotExists` as your `IDbInitializer`.
 ```csharp
 public class MyDbContext : DbContext
 {
-    public TestDbContext()
+    public MyDbContext()
         : base("ConnectionStringName") { }
 
     protected override void OnModelCreating(DbModelBuilder modelBuilder)
     {
-        var sqliteConnectionInitializer = new SqliteContextInitializer<TestDbContext>(
+        var sqliteConnectionInitializer = new SqliteCreateDatabaseIfNotExists<MyDbContext>(
             Database.Connection.ConnectionString, modelBuilder);
         Database.SetInitializer(sqliteConnectionInitializer);
     }
 }
 ```
 
-In a more advanced szenario you may want to populate some core- or test-data after the database was created.
-To do this, inherit from `SqliteContextInitializer<>` and override the `Seed(TestDbContext context)` function.
+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.
 This function will be called, in a own transaction, right after the database was created. This function is only executed if a new database was successfully created.
 ```csharp
-public class TestDbContextInitializer : SqliteContextInitializer<TestDbContext>
+public class MyDbContextContextInitializer : SqliteDropCreateDatabaseAlways<MyDbContext>
 {
-    public TestDbContextInitializer(string connectionString, DbModelBuilder modelBuilder)
+    public MyDbContextInitializer(string connectionString, DbModelBuilder modelBuilder)
         : base(connectionString, modelBuilder) { }
 
-    protected override void Seed(TestDbContext context)
+    protected override void Seed(MyDbContext context)
     {
         context.Set<Player>().Add(new Player());
     }

SQLite.CodeFirst.Console/FootballDbContext.cs

@@ -21,9 +21,11 @@ protected override void OnModelCreating(DbModelBuilder modelBuilder)
             ConfigurePlayerEntity(modelBuilder);
 
             modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
+            // Workaround to support the [Timestamp] annotation
+            modelBuilder.Conventions.Remove<TimestampAttributeConvention>();
 
-            var sqliteConnectionInitializer = new TestDbContextInitializer(Database.Connection.ConnectionString, modelBuilder);
-            Database.SetInitializer(sqliteConnectionInitializer);
+            var initializer = new FootballDbInitializer(Database.Connection.ConnectionString, modelBuilder);
+            Database.SetInitializer(initializer);
         }
 
         private static void ConfigureTeamEntity(DbModelBuilder modelBuilder)
@@ -45,9 +47,9 @@ private static void ConfigurePlayerEntity(DbModelBuilder modelBuilder)
         }
     }
 
-    public class TestDbContextInitializer : SqliteContextInitializer<FootballDbContext>
+    public class FootballDbInitializer : SqliteDropCreateDatabaseAlwaysInitializerBase<FootballDbContext>
     {
-        public TestDbContextInitializer(string connectionString, DbModelBuilder modelBuilder)
+        public FootballDbInitializer(string connectionString, DbModelBuilder modelBuilder)
             : base(connectionString, modelBuilder) { }
 
         protected override void Seed(FootballDbContext context)

SQLite.CodeFirst.Console/Program.cs

@@ -1,5 +1,4 @@
-using System.IO;
-using SQLite.CodeFirst.Console.Entity;
+using SQLite.CodeFirst.Console.Entity;
 
 namespace SQLite.CodeFirst.Console
 {
@@ -9,27 +8,13 @@ static void Main()
         {
             System.Console.WriteLine("Starting Demo Application");
 
-            ClearExistingDbFile();
-
             var context = CreateAndSeedDatabase();
 
             DisplaySeededData(context);
 
             PressEnterToExit();
         }
 
-        private static void ClearExistingDbFile()
-        {
-            System.Console.WriteLine("Check for existing db file.");
-            const string SqliteFilePath = @".\footballDb.sqlite";
-            if (File.Exists(SqliteFilePath))
-            {
-                System.Console.WriteLine("Delete existing db file.");
-                File.Delete(SqliteFilePath);
-            }
-            System.Console.WriteLine();
-        }
-
         private static FootballDbContext CreateAndSeedDatabase()
         {
             System.Console.WriteLine("Create and seed the database.");

SQLite.CodeFirst/SQLite.CodeFirst.csproj

@@ -53,11 +53,13 @@
     <Compile Include="Builder\ForeignKeyStatementBuilder.cs" />
     <Compile Include="Builder\CreateDatabaseStatementBuilder.cs" />
     <Compile Include="Builder\PrimaryKeyStatementBuilder.cs" />
+    <Compile Include="SqliteCreateDatabaseIfNotExists.cs" />
+    <Compile Include="SqliteDropCreateDatabaseAlways.cs" />
     <Compile Include="Statement\ColumnConstraint\MaxLengthConstraint.cs" />
     <Compile Include="Statement\PrimaryKeyStatement.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="SqliteConnectionStringParser.cs" />
-    <Compile Include="SqliteContextInitializer.cs" />
+    <Compile Include="SqliteInitializerBase.cs" />
     <Compile Include="Builder\IStatementBuilder.cs" />
     <Compile Include="SqliteDatabaseCreator.cs" />
     <Compile Include="Statement\ColumnConstraint\ColumnConstraintCollection.cs" />

SQLite.CodeFirst/SqliteCreateDatabaseIfNotExists.cs

@@ -0,0 +1,23 @@
+using System.Data.Entity;
+using System.IO;
+
+namespace SQLite.CodeFirst
+{
+    public class SqliteCreateDatabaseIfNotExists<TContext> : SqliteInitializerBase<TContext>
+        where TContext : DbContext
+    {
+        public SqliteCreateDatabaseIfNotExists(string connectionString, DbModelBuilder modelBuilder)
+            : base(connectionString, modelBuilder) { }
+
+        public override void InitializeDatabase(TContext context)
+        {
+            bool dbExists = File.Exists(DatabaseFilePath);
+            if (dbExists)
+            {
+                return;
+            }
+
+            base.InitializeDatabase(context);
+        }
+    }
+}

SQLite.CodeFirst/SqliteDropCreateDatabaseAlways.cs

@@ -0,0 +1,23 @@
+using System.Data.Entity;
+using System.IO;
+
+namespace SQLite.CodeFirst
+{
+    public class SqliteDropCreateDatabaseAlwaysInitializerBase<TContext> : SqliteInitializerBase<TContext>
+        where TContext : DbContext
+    {
+        public SqliteDropCreateDatabaseAlwaysInitializerBase(string connectionString, DbModelBuilder modelBuilder)
+            : base(connectionString, modelBuilder) { }
+
+        public override void InitializeDatabase(TContext context)
+        {
+            bool dbExists = File.Exists(DatabaseFilePath);
+            if (dbExists)
+            {
+                File.Delete(DatabaseFilePath);
+            }
+
+            base.InitializeDatabase(context);
+        }
+    }
+}

…te.CodeFirst/SqliteContextInitializer.cs SQLite.CodeFirst/SqliteInitializerBase.csSQLite.CodeFirst/SqliteContextInitializer.cs renamed to SQLite.CodeFirst/SqliteInitializerBase.cs SQLite.CodeFirst/SqliteContextInitializer.cs renamed to SQLite.CodeFirst/SqliteInitializerBase.cs

@@ -1,30 +1,23 @@
 using System;
 using System.Data.Entity;
-using System.IO;
 
 namespace SQLite.CodeFirst
 {
-    public class SqliteContextInitializer<TDbContext> : IDatabaseInitializer<TDbContext>
-        where TDbContext : DbContext
+    public abstract class SqliteInitializerBase<TContext> : IDatabaseInitializer<TContext>
+        where TContext : DbContext
     {
-        protected readonly bool dbExists;
-        protected readonly DbModelBuilder modelBuilder;
+        protected readonly DbModelBuilder ModelBuilder;
+        protected readonly string DatabaseFilePath;
 
-        public SqliteContextInitializer(string connectionString, DbModelBuilder modelBuilder)
+        protected SqliteInitializerBase(string connectionString, DbModelBuilder modelBuilder)
         {
-            string path = SqliteConnectionStringParser.GetDataSource(connectionString);
-            dbExists = File.Exists(path);
-            this.modelBuilder = modelBuilder;
+            DatabaseFilePath = SqliteConnectionStringParser.GetDataSource(connectionString);
+            ModelBuilder = modelBuilder;
         }
 
-        public virtual void InitializeDatabase(TDbContext context)
+        public virtual void InitializeDatabase(TContext context)
         {
-            if (dbExists)
-            {
-                return;
-            }
-
-            var model = modelBuilder.Build(context.Database.Connection);
+            var model = ModelBuilder.Build(context.Database.Connection);
 
             using (var transaction = context.Database.BeginTransaction())
             {
@@ -57,6 +50,6 @@ public virtual void InitializeDatabase(TDbContext context)
             }
         }
 
-        protected virtual void Seed(TDbContext context) { }
+        protected virtual void Seed(TContext context) { }
     }
 }