Merge branch 'master' into Issue_21

Conflicts:
	SQLite.CodeFirst/Builder/CreateIndexStatementBuilder.cs

Author: msallin

README.md

@@ -5,7 +5,7 @@
 
 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 several `IDbInitializer` which creates a new SQLite Database, based on your model/code.
+This Project ships several `IDbInitializer` classes. These create new SQLite Databases 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:
@@ -18,23 +18,23 @@ Currently the following is supported:
 - Index (Decorate columns with the `Index` attribute. Indices are automatically created for foreign keys by default. To prevent this you can remove the convetion `ForeignKeyIndexConvention`)
 
 I tried to write the code in a extensible way.
-The logic is divided 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.
 
 ## Install
 Either get the assembly from the latest [GitHub Release Page](https://github.com/msallin/SQLiteCodeFirst/releases) or install the NuGet-Package [SQLite.CodeFirst](https://www.nuget.org/packages/SQLite.CodeFirst/) (`PM> Install-Package SQLite.CodeFirst`).
 
-The project is builded for the target frameworks 4.0 and 4.5.
-That means you can use the SQLite CodeFirst in projects with the following target frameworks.
+The project is built to target.NET framework versions 4.0 and 4.5.
+You can use the SQLite CodeFirst in projects that target the following frameworks:
 - .NET 4.0 (use net40)
 - .NET 4.5 (use net45)
 - .NET 4.5.1 (use net45)
 - .NET 4.5.2 (use net45)
 
 ## How to use
-If you want to let the Entity Framework create the database, if it does not exist, just set `SqliteDropCreateDatabaseAlways<>` or `SqliteCreateDatabaseIfNotExists<>` as your `IDbInitializer<>`.
+When you want to let the Entity Framework create database if it does not exist, just set `SqliteDropCreateDatabaseAlways<>` or `SqliteCreateDatabaseIfNotExists<>` as your `IDbInitializer<>`.
 ```csharp
 public class MyDbContext : DbContext
 {
@@ -50,9 +50,9 @@ public class MyDbContext : DbContext
 }
 ```
 
-In a more advanced scenario you may want to populate some core- or test-data after the database was created.
+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.
+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 MyDbContextContextInitializer : SqliteDropCreateDatabaseAlways<MyDbContext>
 {
@@ -67,5 +67,5 @@ public class MyDbContextContextInitializer : SqliteDropCreateDatabaseAlways<MyDb
 ```
 
 ## 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.
+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.

SQLite.CodeFirst.Console/Entity/Player.cs

@@ -8,11 +8,11 @@ public class Player : IEntity
     {
         public int Id { get; set; }
 
-        [Index] // Automatically named 'IX_FirstName'
+        [Index] // Automatically named 'IX_TeamPlayer_FirstName'
         [MaxLength(50)]
         public string FirstName { get; set; }
 
-        [Index("IX_LN")]
+        [Index("IX_TeamPlayer_LN")] // Test for named index
         [MaxLength(50)]
         public string LastName { get; set; }
 

SQLite.CodeFirst.Console/Entity/Stadion.cs

@@ -7,12 +7,12 @@ public class Stadion
     {
         [Key]
         [Column(Order = 1)]
-        [Index("IX_Main", Order = 2)]
-        public string Name { get; set; }
+        [Index("IX_Stadion_Main", Order = 2)] // Test for combined, named index
+		public string Name { get; set; }
 
         [Key]
         [Column(Order = 2)]
-        [Index("IX_Main", Order = 1)]
+        [Index("IX_Stadion_Main", Order = 1)] // Test for combined, named index
         public string Street { get; set; }
 
         [Key]

SQLite.CodeFirst.Console/FootballDbContext.cs

@@ -22,7 +22,7 @@ protected override void OnModelCreating(DbModelBuilder modelBuilder)
 
             modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
 
-            var initializer = new FootballDbInitializer(Database.Connection.ConnectionString, modelBuilder);
+            var initializer = new FootballDbInitializer(modelBuilder);
             Database.SetInitializer(initializer);
         }
 
@@ -47,8 +47,8 @@ private static void ConfigurePlayerEntity(DbModelBuilder modelBuilder)
 
     public class FootballDbInitializer : SqliteDropCreateDatabaseAlways<FootballDbContext>
     {
-        public FootballDbInitializer(string connectionString, DbModelBuilder modelBuilder)
-            : base(connectionString, modelBuilder) { }
+        public FootballDbInitializer(DbModelBuilder modelBuilder)
+            : base(modelBuilder) { }
 
         protected override void Seed(FootballDbContext context)
         {

SQLite.CodeFirst/Builder/CreateDatabaseStatementBuilder.cs

@@ -25,21 +25,21 @@ public CreateDatabaseStatement BuildStatement()
 
         private IEnumerable<CreateTableStatement> GetCreateTableStatements()
         {
-            foreach (var entityType in edmModel.EntityTypes)
+            foreach (var entitySet in edmModel.Container.EntitySets)
             {
                 ICollection<AssociationType> associationTypes =
-                    edmModel.AssociationTypes.Where(a => a.Constraint.ToRole.Name == entityType.Name).ToList();
+                    edmModel.AssociationTypes.Where(a => a.Constraint.ToRole.Name == entitySet.Name).ToList();
 
-                var tableStatementBuilder = new CreateTableStatementBuilder(entityType, associationTypes);
+                var tableStatementBuilder = new CreateTableStatementBuilder(entitySet, associationTypes);
                 yield return tableStatementBuilder.BuildStatement();
             }
         }
 
         private IEnumerable<CreateIndexStatementCollection> GetCreateIndexStatements()
         {
-            foreach (var entityType in edmModel.EntityTypes)
+            foreach (var entitySet in edmModel.Container.EntitySets)
             {
-                var indexStatementBuilder = new CreateIndexStatementBuilder(entityType);
+                var indexStatementBuilder = new CreateIndexStatementBuilder(entitySet);
                 yield return indexStatementBuilder.BuildStatement();
             }
         }

SQLite.CodeFirst/Builder/CreateIndexStatementBuilder.cs

@@ -11,18 +11,18 @@ namespace SQLite.CodeFirst.Builder
 {
     internal class CreateIndexStatementBuilder : IStatementBuilder<CreateIndexStatementCollection>
     {
-        private readonly EntityType entityType;
+        private readonly EntitySet entitySet;
 
-        public CreateIndexStatementBuilder(EntityType entityType)
+        public CreateIndexStatementBuilder(EntitySet entitySet)
         {
-            this.entityType = entityType;
+            this.entitySet = entitySet;
         }
 
         public CreateIndexStatementCollection BuildStatement()
         {
             IDictionary<string, CreateIndexStatement> createIndexStatments = new Dictionary<string, CreateIndexStatement>();
 
-            foreach (var edmProperty in entityType.Properties)
+            foreach (var edmProperty in entitySet.ElementType.Properties)
             {
                 var indexAnnotations = edmProperty.MetadataProperties
                     .Select(x => x.Value)
@@ -38,7 +38,7 @@ public CreateIndexStatementCollection BuildStatement()
                         {
                             IsUnique = index.IsUnique,
                             Name = indexName,
-                            Table = entityType.GetTableName(),
+                            Table = entitySet.Table,
                             Columns = new Collection<CreateIndexStatement.IndexColumn>()
                         };
                         createIndexStatments.Add(indexName, createIndexStatement);
@@ -55,9 +55,9 @@ public CreateIndexStatementCollection BuildStatement()
             return new CreateIndexStatementCollection(createIndexStatments.Values);
         }
 
-        private static string GetIndexName(EntityType entityType, EdmProperty property, IndexAttribute index)
+        private string GetIndexName(IndexAttribute index, EdmProperty property)
         {
-            return index.Name ?? string.Format("IX_{0}_{1}", entityType.GetTableName(), property.Name);
+            return index.Name ?? string.Format("IX_{0}_{1}", entitySet.ElementType.GetTableName(), property.Name);
         }
     }
 }

SQLite.CodeFirst/Builder/CreateTableStatementBuilder.cs

@@ -7,19 +7,19 @@ namespace SQLite.CodeFirst.Builder
 {
     internal class CreateTableStatementBuilder : IStatementBuilder<CreateTableStatement>
     {
-        private readonly EntityType entityType;
+        private readonly EntitySet entitySet;
         private readonly IEnumerable<AssociationType> associationTypes;
 
-        public CreateTableStatementBuilder(EntityType entityType, IEnumerable<AssociationType> associationTypes)
+        public CreateTableStatementBuilder(EntitySet entitySet, IEnumerable<AssociationType> associationTypes)
         {
-            this.entityType = entityType;
+            this.entitySet = entitySet;
             this.associationTypes = associationTypes;
         }
 
         public CreateTableStatement BuildStatement()
         {
-            var simpleColumnCollection = new ColumnStatementCollectionBuilder(entityType.Properties).BuildStatement();
-            var primaryKeyStatement = new PrimaryKeyStatementBuilder(entityType.KeyMembers).BuildStatement();
+            var simpleColumnCollection = new ColumnStatementCollectionBuilder(entitySet.ElementType.Properties).BuildStatement();
+            var primaryKeyStatement = new PrimaryKeyStatementBuilder(entitySet.ElementType.KeyMembers).BuildStatement();
             var foreignKeyCollection = new ForeignKeyStatementBuilder(associationTypes).BuildStatement();
 
             var columnStatements = new List<IStatement>();
@@ -29,7 +29,7 @@ public CreateTableStatement BuildStatement()
 
             return new CreateTableStatement
             {
-                TableName = entityType.GetTableName(),
+                TableName = entitySet.Table,
                 ColumnStatementCollection = new ColumnStatementCollection(columnStatements)
             };
         }

SQLite.CodeFirst/SqliteConnectionStringParser.cs

@@ -20,7 +20,9 @@ public static IDictionary<string, string> ParseSqliteConnectionString(string con
             foreach (var keyValuePair in keyValuePairs)
             {
                 string[] keyValue = keyValuePair.Split(KeyValueSeperator);
-                keyValuePairDictionary.Add(keyValue[KeyPosition].ToLower(), keyValue[ValuePosition]);
+                if (keyValue.Length >= 2){
+                    keyValuePairDictionary.Add(keyValue[KeyPosition].ToLower(), keyValue[ValuePosition]);
+                }
             }
 
             return keyValuePairDictionary;
@@ -29,6 +31,8 @@ public static IDictionary<string, string> ParseSqliteConnectionString(string con
         public static string GetDataSource(string connectionString)
         {
             var path = ExpandDataDirectory(ParseSqliteConnectionString(connectionString)["data source"]);
+            // remove quotation mark if exists
+            path = path.Trim('"');
             return path;
         }
 

SQLite.CodeFirst/SqliteCreateDatabaseIfNotExists.cs

@@ -6,12 +6,14 @@ namespace SQLite.CodeFirst
     public class SqliteCreateDatabaseIfNotExists<TContext> : SqliteInitializerBase<TContext>
         where TContext : DbContext
     {
-        public SqliteCreateDatabaseIfNotExists(string connectionString, DbModelBuilder modelBuilder)
-            : base(connectionString, modelBuilder) { }
+        public SqliteCreateDatabaseIfNotExists(DbModelBuilder modelBuilder)
+            : base(modelBuilder) { }
 
         public override void InitializeDatabase(TContext context)
         {
-            bool dbExists = File.Exists(DatabaseFilePath);
+            string databseFilePath = GetDatabasePathFromContext(context);
+
+            bool dbExists = File.Exists(databseFilePath);
             if (dbExists)
             {
                 return;

SQLite.CodeFirst/SqliteDropCreateDatabaseAlways.cs

@@ -6,15 +6,17 @@ namespace SQLite.CodeFirst
     public class SqliteDropCreateDatabaseAlways<TContext> : SqliteInitializerBase<TContext>
         where TContext : DbContext
     {
-        public SqliteDropCreateDatabaseAlways(string connectionString, DbModelBuilder modelBuilder)
-            : base(connectionString, modelBuilder) { }
+        public SqliteDropCreateDatabaseAlways(DbModelBuilder modelBuilder)
+            : base(modelBuilder) { }
 
         public override void InitializeDatabase(TContext context)
         {
-            bool dbExists = File.Exists(DatabaseFilePath);
+            string databseFilePath = GetDatabasePathFromContext(context);
+
+            bool dbExists = File.Exists(databseFilePath);
             if (dbExists)
             {
-                File.Delete(DatabaseFilePath);
+                File.Delete(databseFilePath);
             }
 
             base.InitializeDatabase(context);