Support for multiple, none integer, primary keys by using the "Key" annotation.

msallin · msallin · commit b9db2ac81522 · 2015-03-28T13:42:17.000+01:00
diff --git a/README.md b/README.md
@@ -6,15 +6,16 @@ I started with the [code](https://gist.github.com/flaub/1968486e1b3f2b9fddaf) fr
 
 Currently the following is supported:
 - Tables from classes (with table annotation)
-- Columns from properties
-- ForeignKey constraint (1-n relationships)
-- Cascade on delete
-- PrimaryKey constraint (An int PrimaryKey will automatically be incremented)
+- Columns from properties (with key annotation)
+- Auto increment (An int PrimaryKey will automatically be incremented)
+- ForeignKey constraint (1-n relationships, support for 'Cascade on delete')
 - Not Null constraint
 
 I tried to write the code in a extensible way.
 The logic is devided into two main parts. Builder and Statement.
-The Builder-Part knows how to translate the EdmModel into statements where a statement class creates the SQLite-SQL-Code. The structure of the statements is influenced by the [SQLite Language Specification](https://www.sqlite.org/lang.html).
+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`.
diff --git a/SQLite.CodeFirst.Console/Entity/Player.cs b/SQLite.CodeFirst.Console/Entity/Player.cs
@@ -1,10 +1,16 @@
-﻿
+﻿using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
 namespace SQLite.CodeFirst.Console.Entity
 {
-    public class Player : IEntity
+    public class Player
     {
-        public int Id { get; set; }
-        public string Name { get; set; }
+        [Key]
+        [Column(Order = 1)] 
+        public string FirstName { get; set; }
+        [Key]
+        [Column(Order = 2)] 
+        public string LastName { get; set; }
         public Team Team { get; set; }
     }
 }
diff --git a/SQLite.CodeFirst.Console/TestDbContext.cs b/SQLite.CodeFirst.Console/TestDbContext.cs
@@ -1,6 +1,4 @@
-﻿using System;
-using System.Data.Entity;
-using System.Data.Entity.ModelConfiguration.Configuration;
+﻿using System.Data.Entity;
 using System.Data.Entity.ModelConfiguration.Conventions;
 using SQLite.CodeFirst.Console.Entity;
 
@@ -32,8 +30,7 @@ private static void ConfigurePlayerEntity(DbModelBuilder modelBuilder)
         {
             modelBuilder.RegisterEntityType(typeof(Player));
 
-            modelBuilder.Entity<Player>().HasKey(player => player.Id);
-            modelBuilder.Entity<Player>().Property(player => player.Name).HasMaxLength(10);
+            modelBuilder.Entity<Player>().Property(player => player.FirstName).HasMaxLength(10);
 
             modelBuilder.Entity<Player>().ToTable("TeamPlayer");
 
diff --git a/SQLite.CodeFirst/Builder/ColumnStatementCollectionBuilder.cs b/SQLite.CodeFirst/Builder/ColumnStatementCollectionBuilder.cs
@@ -6,22 +6,18 @@
 
 namespace SQLite.CodeFirst.Builder
 {
-    internal class ColumnCollectionBuilder : IStatementBuilder<ColumnCollection>
+    internal class ColumnStatementCollectionBuilder : IStatementBuilder<ColumnStatementCollection>
     {
         private readonly IEnumerable<EdmProperty> properties;
 
-        public ColumnCollectionBuilder(IEnumerable<EdmProperty> properties)
+        public ColumnStatementCollectionBuilder(IEnumerable<EdmProperty> properties)
         {
             this.properties = properties;
         }
 
-        public ColumnCollection BuildStatement()
+        public ColumnStatementCollection BuildStatement()
         {
-            var columnDefStatement = new ColumnCollection
-            {
-                ColumnStatements = CreateColumnStatements().ToList()
-            };
-
+            var columnDefStatement = new ColumnStatementCollection(CreateColumnStatements().ToList());
             return columnDefStatement;
         }
 
@@ -33,24 +29,20 @@ private IEnumerable<ColumnStatement> CreateColumnStatements()
                 {
                     ColumnName = property.Name,
                     TypeName = property.TypeName,
-                    ColumnConstraints = new ColumnConstraintCollection
-                    {
-                        ColumnConstraints = new List<IColumnConstraint>()
-                    }
+                    ColumnConstraints = new ColumnConstraintCollection()
                 };
 
+                AdjustDatatypeForAutogenerationIfNecessary(property, columnStatement);
                 AddNullConstraintIfNecessary(property, columnStatement);
-                AddPrimaryKeyIfNecessary(property, columnStatement);
 
                 yield return columnStatement;
             }
         }
 
-        private static void AddPrimaryKeyIfNecessary(EdmProperty property, ColumnStatement columnStatement)
+        private static void AdjustDatatypeForAutogenerationIfNecessary(EdmProperty property, ColumnStatement columnStatement)
         {
             if (property.StoreGeneratedPattern == StoreGeneratedPattern.Identity)
             {
-                columnStatement.ColumnConstraints.ColumnConstraints.Add(new PrimaryKeyConstraint());
                 // Must be INTEGER else SQLite will not generate the Ids
                 columnStatement.TypeName = columnStatement.TypeName.ToLower() == "int" ? "INTEGER" : columnStatement.TypeName;
             }
@@ -59,8 +51,10 @@ private static void AddPrimaryKeyIfNecessary(EdmProperty property, ColumnStateme
         private static void AddNullConstraintIfNecessary(EdmProperty property, ColumnStatement columnStatement)
         {
             if (!property.Nullable && property.StoreGeneratedPattern != StoreGeneratedPattern.Identity)
+            {
                 // Only mark it as NotNull if it should not be generated.
-                columnStatement.ColumnConstraints.ColumnConstraints.Add(new NotNullConstraint());
+                columnStatement.ColumnConstraints.Add(new NotNullConstraint());
+            }
         }
     }
 }
diff --git a/SQLite.CodeFirst/Builder/CreateDatabaseStatementBuilder.cs b/SQLite.CodeFirst/Builder/CreateDatabaseStatementBuilder.cs
@@ -16,11 +16,7 @@ public CreateDatabaseStatementBuilder(EdmModel edmModel)
 
         public CreateDatabaseStatement BuildStatement()
         {
-            var createDatabaseStatement = new CreateDatabaseStatement
-            {
-                CreateTableStatements = GetCreateTableStatements()
-            };
-
+            var createDatabaseStatement = new CreateDatabaseStatement(GetCreateTableStatements());
             return createDatabaseStatement;
         }
 
diff --git a/SQLite.CodeFirst/Builder/CreateTableStatementBuilder.cs b/SQLite.CodeFirst/Builder/CreateTableStatementBuilder.cs
@@ -18,17 +18,19 @@ public CreateTableStatementBuilder(EntityType entityType, IEnumerable<Associatio
 
         public CreateTableStatement BuildStatement()
         {
-            var simpleColumnCollection = new ColumnCollectionBuilder(entityType.Properties).BuildStatement();
-            var foreignKeyCollection = new ForeignKeyCollectionBuilder(associationTypes).BuildStatement();
-            var columnCollection = new ColumnCollection
-            {
-                ColumnStatements = simpleColumnCollection.ColumnStatements.Concat(foreignKeyCollection.ColumnStatements)
-            };
+            var simpleColumnCollection = new ColumnStatementCollectionBuilder(entityType.Properties).BuildStatement();
+            var primaryKeyStatement = new PrimaryKeyStatementBuilder(entityType.KeyMembers).BuildStatement();
+            var foreignKeyCollection = new ForeignKeyStatementBuilder(associationTypes).BuildStatement();
+
+            List<IStatement> columnStatements = new List<IStatement>();
+            columnStatements.AddRange(simpleColumnCollection);
+            columnStatements.Add(primaryKeyStatement);
+            columnStatements.AddRange(foreignKeyCollection);
 
             return new CreateTableStatement
             {
                 TableName = GetTableName(),
-                ColumnCollection = columnCollection
+                ColumnStatementCollection = new ColumnStatementCollection(columnStatements)
             };
         }
 
diff --git a/SQLite.CodeFirst/Builder/ForeignKeyStatementBuilder.cs b/SQLite.CodeFirst/Builder/ForeignKeyStatementBuilder.cs
@@ -5,22 +5,18 @@
 
 namespace SQLite.CodeFirst.Builder
 {
-    internal class ForeignKeyCollectionBuilder : IStatementBuilder<ColumnCollection>
+    internal class ForeignKeyStatementBuilder : IStatementBuilder<ColumnStatementCollection>
     {
         private readonly IEnumerable<AssociationType> associationTypes;
 
-        public ForeignKeyCollectionBuilder(IEnumerable<AssociationType> associationTypes)
+        public ForeignKeyStatementBuilder(IEnumerable<AssociationType> associationTypes)
         {
             this.associationTypes = associationTypes;
         }
 
-        public ColumnCollection BuildStatement()
+        public ColumnStatementCollection BuildStatement()
         {
-            var columnDefStatement = new ColumnCollection
-            {
-                ColumnStatements = GetForeignKeyStatements().ToList()
-            };
-
+            var columnDefStatement = new ColumnStatementCollection(GetForeignKeyStatements().ToList());
             return columnDefStatement;
         }
 
diff --git a/SQLite.CodeFirst/Builder/PrimaryKeyStatementBuilder.cs b/SQLite.CodeFirst/Builder/PrimaryKeyStatementBuilder.cs
@@ -0,0 +1,22 @@
+﻿using System.Collections.Generic;
+using System.Data.Entity.Core.Metadata.Edm;
+using System.Linq;
+using SQLite.CodeFirst.Statement;
+
+namespace SQLite.CodeFirst.Builder
+{
+    internal class PrimaryKeyStatementBuilder : IStatementBuilder<PrimaryKeyStatement>
+    {
+        private readonly IEnumerable<EdmMember> keyMembers;
+
+        public PrimaryKeyStatementBuilder(IEnumerable<EdmMember> keyMembers)
+        {
+            this.keyMembers = keyMembers;
+        }
+
+        public PrimaryKeyStatement BuildStatement()
+        {
+            return new PrimaryKeyStatement(keyMembers.Select(km => km.Name));
+        }
+    }
+}
diff --git a/SQLite.CodeFirst/SQLite.CodeFirst.csproj b/SQLite.CodeFirst/SQLite.CodeFirst.csproj
@@ -46,11 +46,14 @@
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Data" />
+    <Reference Include="System.Data.Entity" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Builder\ColumnCollectionBuilder.cs" />
-    <Compile Include="Builder\ForeignKeyCollectionBuilder.cs" />
+    <Compile Include="Builder\ColumnStatementCollectionBuilder.cs" />
+    <Compile Include="Builder\ForeignKeyStatementBuilder.cs" />
     <Compile Include="Builder\CreateDatabaseStatementBuilder.cs" />
+    <Compile Include="Builder\PrimaryKeyStatementBuilder.cs" />
+    <Compile Include="Statement\PrimaryKeyStatement.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="SqliteConnectionStringParser.cs" />
     <Compile Include="SqliteContextInitializer.cs" />
@@ -60,7 +63,7 @@
     <Compile Include="Statement\ForeignKeyStatement.cs" />
     <Compile Include="Statement\ColumnConstraint\IColumnConstraint.cs" />
     <Compile Include="Statement\ColumnConstraint\NotNullConstraint.cs" />
-    <Compile Include="Statement\ColumnCollection.cs" />
+    <Compile Include="Statement\ColumnStatementCollection.cs" />
     <Compile Include="Statement\ColumnStatement.cs" />
     <Compile Include="Statement\CreateDatabaseStatement.cs" />
     <Compile Include="Statement\CreateTableStatement.cs" />
diff --git a/SQLite.CodeFirst/Statement/ColumnCollection.cs b/SQLite.CodeFirst/Statement/ColumnCollection.cs
diff --git a/SQLite.CodeFirst/Statement/ColumnConstraint/ColumnConstraintCollection.cs b/SQLite.CodeFirst/Statement/ColumnConstraint/ColumnConstraintCollection.cs
@@ -1,18 +1,27 @@
 ﻿using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Linq;
 
 namespace SQLite.CodeFirst.Statement.ColumnConstraint
 {
-    internal class ColumnConstraintCollection : IColumnConstraint
+    internal class ColumnConstraintCollection : Collection<IColumnConstraint>, IColumnConstraint
     {
         private const string ConstraintStatementSeperator = " ";
 
-        public ICollection<IColumnConstraint> ColumnConstraints { get; set; }
+        public ColumnConstraintCollection() { }
+
+        public ColumnConstraintCollection(IEnumerable<IColumnConstraint> columnConstraints)
+        {
+            foreach (var columnConstraint in columnConstraints)
+            {
+                Add(columnConstraint);
+            }
+        }
 
         public string CreateStatement()
         {
-            return String.Join(ConstraintStatementSeperator, ColumnConstraints.Select(c => c.CreateStatement()));
+            return String.Join(ConstraintStatementSeperator, this.Select(c => c.CreateStatement()));
         }
     }
 }
diff --git a/SQLite.CodeFirst/Statement/ColumnStatementCollection.cs b/SQLite.CodeFirst/Statement/ColumnStatementCollection.cs
@@ -0,0 +1,27 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+
+namespace SQLite.CodeFirst.Statement
+{
+    internal class ColumnStatementCollection : Collection<IStatement>, IStatement
+    {
+        private const string ColumnStatementSeperator = ", ";
+
+        public ColumnStatementCollection() { }
+
+        public ColumnStatementCollection(IEnumerable<IStatement> statements)
+        {
+            foreach (var statement in statements)
+            {
+                Add(statement);
+            }
+        }
+
+        public string CreateStatement()
+        {
+            return String.Join(ColumnStatementSeperator, this.Select(c => c.CreateStatement()));
+        }
+    }
+}
diff --git a/SQLite.CodeFirst/Statement/CreateDatabaseStatement.cs b/SQLite.CodeFirst/Statement/CreateDatabaseStatement.cs
@@ -1,18 +1,27 @@
 ﻿using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Linq;
 
 namespace SQLite.CodeFirst.Statement
 {
-    internal class CreateDatabaseStatement : IStatement
+    internal class CreateDatabaseStatement : Collection<CreateTableStatement>, IStatement
     {
         private const string CreateTableStatementSeperator = "\r\n";
 
-        public IEnumerable<CreateTableStatement> CreateTableStatements { get; set; }
+        public CreateDatabaseStatement() { }
+
+        public CreateDatabaseStatement(IEnumerable<CreateTableStatement> createTableStatements)
+        {
+            foreach (var createTableStatement in createTableStatements)
+            {
+                Add(createTableStatement);
+            }
+        }
 
         public string CreateStatement()
         {
-            return String.Join(CreateTableStatementSeperator, CreateTableStatements.Select(c => c.CreateStatement()));
+            return String.Join(CreateTableStatementSeperator, this.Select(c => c.CreateStatement()));
         }
     }
 }
diff --git a/SQLite.CodeFirst/Statement/CreateTableStatement.cs b/SQLite.CodeFirst/Statement/CreateTableStatement.cs
@@ -7,14 +7,14 @@ internal class CreateTableStatement : IStatement
         private const string Template = "CREATE TABLE {table-name} ({column-def});";
 
         public string TableName { get; set; }
-        public ColumnCollection ColumnCollection { get; set; }
+        public ColumnStatementCollection ColumnStatementCollection { get; set; }
 
         public string CreateStatement()
         {
             var sb = new StringBuilder(Template);
 
             sb.Replace("{table-name}", TableName);
-            sb.Replace("{column-def}", ColumnCollection.CreateStatement());
+            sb.Replace("{column-def}", ColumnStatementCollection.CreateStatement());
 
             return sb.ToString();
         }
diff --git a/SQLite.CodeFirst/Statement/PrimaryKeyStatement.cs b/SQLite.CodeFirst/Statement/PrimaryKeyStatement.cs
@@ -0,0 +1,26 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace SQLite.CodeFirst.Statement
+{
+    internal class PrimaryKeyStatement : Collection<string>, IStatement
+    {
+        private const string Template = "PRIMARY KEY({primary-keys})";
+        private const string PrimaryKeyColumnNameSeperator = ", ";
+
+        public PrimaryKeyStatement(IEnumerable<string> keyMembers)
+        {
+            foreach (var keyMember in keyMembers)
+            {
+                Add(keyMember);
+            }
+        }
+
+        public string CreateStatement()
+        {
+            string primaryKeys = String.Join(PrimaryKeyColumnNameSeperator, this);
+            return Template.Replace("{primary-keys}", primaryKeys);
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,16 @@`
`1`		`-`
	`1`	`+using System.ComponentModel.DataAnnotations;`
	`2`	`+using System.ComponentModel.DataAnnotations.Schema;`
	`3`	`+`
`2`	`4`	`namespace SQLite.CodeFirst.Console.Entity`
`3`	`5`	`{`
`4`		`- public class Player : IEntity`
	`6`	`+ public class Player`
`5`	`7`	`{`
`6`		`- public int Id { get; set; }`
`7`		`- public string Name { get; set; }`
	`8`	`+ [Key]`
	`9`	`+ [Column(Order = 1)]`
	`10`	`+ public string FirstName { get; set; }`
	`11`	`+ [Key]`
	`12`	`+ [Column(Order = 2)]`
	`13`	`+ public string LastName { get; set; }`
`8`	`14`	`public Team Team { get; set; }`
`9`	`15`	`}`
`10`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,22 +6,18 @@`
`6`	`6`
`7`	`7`	`namespace SQLite.CodeFirst.Builder`
`8`	`8`	`{`
`9`		`- internal class ColumnCollectionBuilder : IStatementBuilder<ColumnCollection>`
	`9`	`+ internal class ColumnStatementCollectionBuilder : IStatementBuilder<ColumnStatementCollection>`
`10`	`10`	`{`
`11`	`11`	`private readonly IEnumerable<EdmProperty> properties;`
`12`	`12`
`13`		`- public ColumnCollectionBuilder(IEnumerable<EdmProperty> properties)`
	`13`	`+ public ColumnStatementCollectionBuilder(IEnumerable<EdmProperty> properties)`
`14`	`14`	`{`
`15`	`15`	`this.properties = properties;`
`16`	`16`	`}`
`17`	`17`
`18`		`- public ColumnCollection BuildStatement()`
	`18`	`+ public ColumnStatementCollection BuildStatement()`
`19`	`19`	`{`
`20`		`- var columnDefStatement = new ColumnCollection`
`21`		`- {`
`22`		`- ColumnStatements = CreateColumnStatements().ToList()`
`23`		`- };`
`24`		`-`
	`20`	`+ var columnDefStatement = new ColumnStatementCollection(CreateColumnStatements().ToList());`
`25`	`21`	`return columnDefStatement;`
`26`	`22`	`}`
`27`	`23`
`@@ -33,24 +29,20 @@ private IEnumerable<ColumnStatement> CreateColumnStatements()`
`33`	`29`	`{`
`34`	`30`	`ColumnName = property.Name,`
`35`	`31`	`TypeName = property.TypeName,`
`36`		`- ColumnConstraints = new ColumnConstraintCollection`
`37`		`- {`
`38`		`- ColumnConstraints = new List<IColumnConstraint>()`
`39`		`- }`
	`32`	`+ ColumnConstraints = new ColumnConstraintCollection()`
`40`	`33`	`};`
`41`	`34`
	`35`	`+ AdjustDatatypeForAutogenerationIfNecessary(property, columnStatement);`
`42`	`36`	`AddNullConstraintIfNecessary(property, columnStatement);`
`43`		`- AddPrimaryKeyIfNecessary(property, columnStatement);`
`44`	`37`
`45`	`38`	`yield return columnStatement;`
`46`	`39`	`}`
`47`	`40`	`}`
`48`	`41`
`49`		`- private static void AddPrimaryKeyIfNecessary(EdmProperty property, ColumnStatement columnStatement)`
	`42`	`+ private static void AdjustDatatypeForAutogenerationIfNecessary(EdmProperty property, ColumnStatement columnStatement)`
`50`	`43`	`{`
`51`	`44`	`if (property.StoreGeneratedPattern == StoreGeneratedPattern.Identity)`
`52`	`45`	`{`
`53`		`- columnStatement.ColumnConstraints.ColumnConstraints.Add(new PrimaryKeyConstraint());`
`54`	`46`	`// Must be INTEGER else SQLite will not generate the Ids`
`55`	`47`	`columnStatement.TypeName = columnStatement.TypeName.ToLower() == "int" ? "INTEGER" : columnStatement.TypeName;`
`56`	`48`	`}`
`@@ -59,8 +51,10 @@ private static void AddPrimaryKeyIfNecessary(EdmProperty property, ColumnStateme`
`59`	`51`	`private static void AddNullConstraintIfNecessary(EdmProperty property, ColumnStatement columnStatement)`
`60`	`52`	`{`
`61`	`53`	`if (!property.Nullable && property.StoreGeneratedPattern != StoreGeneratedPattern.Identity)`
	`54`	`+ {`
`62`	`55`	`// Only mark it as NotNull if it should not be generated.`
`63`		`- columnStatement.ColumnConstraints.ColumnConstraints.Add(new NotNullConstraint());`
	`56`	`+ columnStatement.ColumnConstraints.Add(new NotNullConstraint());`
	`57`	`+ }`
`64`	`58`	`}`
`65`	`59`	`}`
`66`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,11 +16,7 @@ public CreateDatabaseStatementBuilder(EdmModel edmModel)`
`16`	`16`
`17`	`17`	`public CreateDatabaseStatement BuildStatement()`
`18`	`18`	`{`
`19`		`- var createDatabaseStatement = new CreateDatabaseStatement`
`20`		`- {`
`21`		`- CreateTableStatements = GetCreateTableStatements()`
`22`		`- };`
`23`		`-`
	`19`	`+ var createDatabaseStatement = new CreateDatabaseStatement(GetCreateTableStatements());`
`24`	`20`	`return createDatabaseStatement;`
`25`	`21`	`}`
`26`	`22`
Original file line number	Diff line number	Diff line change
`@@ -5,22 +5,18 @@`
`5`	`5`
`6`	`6`	`namespace SQLite.CodeFirst.Builder`
`7`	`7`	`{`
`8`		`- internal class ForeignKeyCollectionBuilder : IStatementBuilder<ColumnCollection>`
	`8`	`+ internal class ForeignKeyStatementBuilder : IStatementBuilder<ColumnStatementCollection>`
`9`	`9`	`{`
`10`	`10`	`private readonly IEnumerable<AssociationType> associationTypes;`
`11`	`11`
`12`		`- public ForeignKeyCollectionBuilder(IEnumerable<AssociationType> associationTypes)`
	`12`	`+ public ForeignKeyStatementBuilder(IEnumerable<AssociationType> associationTypes)`
`13`	`13`	`{`
`14`	`14`	`this.associationTypes = associationTypes;`
`15`	`15`	`}`
`16`	`16`
`17`		`- public ColumnCollection BuildStatement()`
	`17`	`+ public ColumnStatementCollection BuildStatement()`
`18`	`18`	`{`
`19`		`- var columnDefStatement = new ColumnCollection`
`20`		`- {`
`21`		`- ColumnStatements = GetForeignKeyStatements().ToList()`
`22`		`- };`
`23`		`-`
	`19`	`+ var columnDefStatement = new ColumnStatementCollection(GetForeignKeyStatements().ToList());`
`24`	`20`	`return columnDefStatement;`
`25`	`21`	`}`
`26`	`22`