Merge branch 'master' into Issue_22

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/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

@@ -4,25 +4,24 @@
 using System.Data.Entity.Core.Metadata.Edm;
 using System.Data.Entity.Infrastructure.Annotations;
 using System.Linq;
-using SQLite.CodeFirst.Extensions;
 using SQLite.CodeFirst.Statement;
 
 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 +37,7 @@ public CreateIndexStatementCollection BuildStatement()
                         {
                             IsUnique = index.IsUnique,
                             Name = indexName,
-                            Table = entityType.GetTableName(),
+                            Table = entitySet.Table,
                             Columns = new Collection<CreateIndexStatement.IndexColumn>()
                         };
                         createIndexStatments.Add(indexName, createIndexStatement);

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;
         }
 

release_appveyor.yml

@@ -15,18 +15,14 @@ build:
   verbosity: normal
 after_build:
 - ps: >-
-    Write-Host $env:APPVEYOR_BUILD_FOLDER
-
     cd $env:APPVEYOR_BUILD_FOLDER
 
     cd '.nuget'
 
     ./nuget.exe pack '..\SQLite.CodeFirst\SQLite.CodeFirst.csproj' -Properties -Symbols -OutputDirectory '..\SQLite.CodeFirst\bin'
 artifacts:
-- path: SQLite.CodeFirst\bin\Debug**\SQLite.CodeFirst.*
-  name: Debug
-- path: SQLite.CodeFirst\bin\Release\**\SQLite.CodeFirst.dll
-  name: Release
+- path: SQLite.CodeFirst\bin
+  name: Assemblies
 - path: SQLite.CodeFirst\bin\*.nupkg
   name: NuPkg
 deploy:
@@ -41,7 +37,7 @@ deploy:
   description: https://www.nuget.org/packages/SQLite.CodeFirst/
   auth_token:
     secure: e3cqaFy9PzI9TAdZJBIDy97Bfbwa7j0EXe2yw7Ev9aJXK0Q+3mnULqb1VU4P7BWR
-  artifact: Release
+  artifact: Assemblies,NuPkg
   draft: true
   on:
     branch: master