81: Added possibility to use pure autoincrement db column type.

okipol88 · msallin · commit 97b962de2ade · 2017-03-03T23:35:49.000+01:00
diff --git a/SQLite.CodeFirst.Console/Entity/Team.cs b/SQLite.CodeFirst.Console/Entity/Team.cs
@@ -6,6 +6,7 @@ namespace SQLite.CodeFirst.Console.Entity
 {
     public class Team : IEntity
     {
+        [Autoincrement]
         public int Id { get; set; }
 
         [Index("IX_Team_TeamsName")] // Test for named index.
diff --git a/SQLite.CodeFirst.Test/IntegrationTests/SqlGenerationTest.cs b/SQLite.CodeFirst.Test/IntegrationTests/SqlGenerationTest.cs
@@ -14,13 +14,13 @@ namespace SQLite.CodeFirst.Test.IntegrationTests
     public class SqlGenerationTest
     {
         private const string ReferenceSql =
-            @"CREATE TABLE ""MyTable"" ([Id] int NOT NULL, [Name] nvarchar NOT NULL, PRIMARY KEY(Id), FOREIGN KEY (Id) REFERENCES ""Coaches""(Id));
-CREATE TABLE ""Coaches"" ([Id] INTEGER, [FirstName] nvarchar (50) COLLATE NOCASE, [LastName] nvarchar (50), [Street] nvarchar (100), [City] nvarchar NOT NULL, PRIMARY KEY(Id));
-CREATE TABLE ""TeamPlayer"" ([Id] INTEGER, [Number] int NOT NULL, [TeamId] int NOT NULL, [FirstName] nvarchar (50) COLLATE NOCASE, [LastName] nvarchar (50), [Street] nvarchar (100), [City] nvarchar NOT NULL, [Mentor_Id] int, PRIMARY KEY(Id), FOREIGN KEY (Mentor_Id) REFERENCES ""TeamPlayer""(Id), FOREIGN KEY (TeamId) REFERENCES ""MyTable""(Id) ON DELETE CASCADE);
+            @"CREATE TABLE ""MyTable"" ([Id] INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, [Name] nvarchar NOT NULL, FOREIGN KEY (Id) REFERENCES ""Coaches""(Id));
+CREATE TABLE ""Coaches"" ([Id] INTEGER PRIMARY KEY, [FirstName] nvarchar (50) COLLATE NOCASE, [LastName] nvarchar (50), [Street] nvarchar (100), [City] nvarchar NOT NULL);
+CREATE TABLE ""TeamPlayer"" ([Id] INTEGER PRIMARY KEY, [Number] int NOT NULL, [TeamId] int NOT NULL, [FirstName] nvarchar (50) COLLATE NOCASE, [LastName] nvarchar (50), [Street] nvarchar (100), [City] nvarchar NOT NULL, [Mentor_Id] int, FOREIGN KEY (Mentor_Id) REFERENCES ""TeamPlayer""(Id), FOREIGN KEY (TeamId) REFERENCES ""MyTable""(Id) ON DELETE CASCADE);
 CREATE TABLE ""Stadions"" ([Name] nvarchar (128) NOT NULL, [Street] nvarchar (128) NOT NULL, [City] nvarchar (128) NOT NULL, [Team_Id] int NOT NULL, PRIMARY KEY(Name, Street, City), FOREIGN KEY (Team_Id) REFERENCES ""MyTable""(Id) ON DELETE CASCADE);
-CREATE TABLE ""Foos"" ([FooId] INTEGER, [Name] nvarchar, [FooSelf1Id] int, [FooSelf2Id] int, [FooSelf3Id] int, PRIMARY KEY(FooId), FOREIGN KEY (FooSelf1Id) REFERENCES ""Foos""(FooId), FOREIGN KEY (FooSelf2Id) REFERENCES ""Foos""(FooId), FOREIGN KEY (FooSelf3Id) REFERENCES ""Foos""(FooId));
-CREATE TABLE ""FooSelves"" ([FooSelfId] INTEGER, [FooId] int NOT NULL, [Number] int NOT NULL, PRIMARY KEY(FooSelfId), FOREIGN KEY (FooId) REFERENCES ""Foos""(FooId) ON DELETE CASCADE);
-CREATE TABLE ""FooSteps"" ([FooStepId] INTEGER, [FooId] int NOT NULL, [Number] int NOT NULL, PRIMARY KEY(FooStepId), FOREIGN KEY (FooId) REFERENCES ""Foos""(FooId) ON DELETE CASCADE);
+CREATE TABLE ""Foos"" ([FooId] INTEGER PRIMARY KEY, [Name] nvarchar, [FooSelf1Id] int, [FooSelf2Id] int, [FooSelf3Id] int, FOREIGN KEY (FooSelf1Id) REFERENCES ""Foos""(FooId), FOREIGN KEY (FooSelf2Id) REFERENCES ""Foos""(FooId), FOREIGN KEY (FooSelf3Id) REFERENCES ""Foos""(FooId));
+CREATE TABLE ""FooSelves"" ([FooSelfId] INTEGER PRIMARY KEY, [FooId] int NOT NULL, [Number] int NOT NULL, FOREIGN KEY (FooId) REFERENCES ""Foos""(FooId) ON DELETE CASCADE);
+CREATE TABLE ""FooSteps"" ([FooStepId] INTEGER PRIMARY KEY, [FooId] int NOT NULL, [Number] int NOT NULL, FOREIGN KEY (FooId) REFERENCES ""Foos""(FooId) ON DELETE CASCADE);
 CREATE  INDEX ""IX_MyTable_Id"" ON ""MyTable"" (Id);
 CREATE  INDEX IX_Team_TeamsName ON ""MyTable"" (Name);
 
diff --git a/SQLite.CodeFirst.Test/SQLite.CodeFirst.Test.csproj b/SQLite.CodeFirst.Test/SQLite.CodeFirst.Test.csproj
@@ -97,6 +97,7 @@
     <Compile Include="IntegrationTests\MemoryDbTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="UnitTests\Statement\ColumnConstraint\MaxLengthConstraint.cs" />
+    <Compile Include="UnitTests\Statement\ColumnConstraint\PrimaryKeyConstraintTest.cs" />
     <Compile Include="UnitTests\Statement\ColumnConstraint\ColumnConstraintCollectionTest.cs" />
     <Compile Include="UnitTests\Statement\ColumnConstraint\NotNullConstraintTest.cs" />
     <Compile Include="UnitTests\Statement\ColumnConstraint\CollateConstraintTest.cs" />
diff --git a/SQLite.CodeFirst.Test/UnitTests/Statement/ColumnConstraint/PrimaryKeyConstraintTest.cs b/SQLite.CodeFirst.Test/UnitTests/Statement/ColumnConstraint/PrimaryKeyConstraintTest.cs
@@ -0,0 +1,25 @@
+﻿using Microsoft.VisualStudio.TestTools.UnitTesting;
+using SQLite.CodeFirst.Statement.ColumnConstraint;
+
+namespace SQLite.CodeFirst.Test.UnitTests.Statement.ColumnConstraint
+{
+    [TestClass]
+    public class PrimaryKeyConstraintTest
+    {
+        [TestMethod]
+        public void CreateStatement_StatementIsCorrect_WithAutoincrement()
+        {
+            var primaryKeyConstraint = new PrimaryKeyConstraint { Autoincrement = true };
+            string output = primaryKeyConstraint.CreateStatement();
+            Assert.AreEqual(output, "PRIMARY KEY AUTOINCREMENT");
+        }
+
+        [TestMethod]
+        public void CreateStatement_StatementIsCorrect()
+        {
+            var primaryKeyConstraint = new PrimaryKeyConstraint();
+            string output = primaryKeyConstraint.CreateStatement();
+            Assert.AreEqual(output, "PRIMARY KEY");
+        }
+    }
+}
diff --git a/SQLite.CodeFirst.Test/UnitTests/Statement/PrimaryKeyStatementTest.cs b/SQLite.CodeFirst.Test/UnitTests/Statement/PrimaryKeyStatementTest.cs
@@ -12,7 +12,7 @@ public void CreateStatementWithOneKeyTest()
         {
             const string keyMember1 = "keyMember1";
 
-            var primaryKeyStatement = new PrimaryKeyStatement(new List<string> { keyMember1 });
+            var primaryKeyStatement = new CompositePrimaryKeyStatement(new List<string> { keyMember1 });
             Assert.AreEqual(primaryKeyStatement.Count, 1);
             Assert.AreEqual(primaryKeyStatement.CreateStatement(), "PRIMARY KEY(keyMember1)");
         }
@@ -23,7 +23,7 @@ public void CreateStatementWithTwoKeyTest()
             const string keyMember1 = "keyMember1";
             const string keyMember2 = "keyMember2";
 
-            var primaryKeyStatement = new PrimaryKeyStatement(new List<string> { keyMember1, keyMember2 });
+            var primaryKeyStatement = new CompositePrimaryKeyStatement(new List<string> { keyMember1, keyMember2 });
             Assert.AreEqual(primaryKeyStatement.Count, 2);
             Assert.AreEqual(primaryKeyStatement.CreateStatement(), "PRIMARY KEY(keyMember1, keyMember2)");
         }
diff --git a/SQLite.CodeFirst/Internal/Builder/ColumnStatementCollectionBuilder.cs b/SQLite.CodeFirst/Internal/Builder/ColumnStatementCollectionBuilder.cs
@@ -1,6 +1,5 @@
 ﻿using System.Collections.Generic;
 using System.Data.Entity.Core.Metadata.Edm;
-using System.Globalization;
 using System.Linq;
 using SQLite.CodeFirst.Extensions;
 using SQLite.CodeFirst.Statement;
@@ -11,10 +10,12 @@ namespace SQLite.CodeFirst.Builder
     internal class ColumnStatementCollectionBuilder : IStatementBuilder<ColumnStatementCollection>
     {
         private readonly IEnumerable<EdmProperty> properties;
+        private readonly IEnumerable<EdmProperty> keyMembers;
 
-        public ColumnStatementCollectionBuilder(IEnumerable<EdmProperty> properties)
+        public ColumnStatementCollectionBuilder(IEnumerable<EdmProperty> properties, IEnumerable<EdmProperty> keyMembers)
         {
             this.properties = properties;
+            this.keyMembers = keyMembers;
         }
 
         public ColumnStatementCollection BuildStatement()
@@ -39,6 +40,7 @@ private IEnumerable<ColumnStatement> CreateColumnStatements()
                 AddNullConstraintIfNecessary(property, columnStatement);
                 AddUniqueConstraintIfNecessary(property, columnStatement);
                 AddCollationConstraintIfNecessary(property, columnStatement);
+                AddPrimaryKeyConstraintAndAdjustTypeIfNecessary(property, columnStatement);
 
                 yield return columnStatement;
             }
@@ -57,7 +59,7 @@ private static void AdjustDatatypeForAutogenerationIfNecessary(EdmProperty prope
             if (property.StoreGeneratedPattern == StoreGeneratedPattern.Identity)
             {
                 // Must be INTEGER else SQLite will not generate the Ids
-                columnStatement.TypeName = columnStatement.TypeName.ToUpperInvariant() == "INT" ? "INTEGER" : columnStatement.TypeName;
+                ConvertIntegerType(columnStatement);
             }
         }
 
@@ -87,5 +89,25 @@ private static void AddUniqueConstraintIfNecessary(EdmProperty property, ColumnS
                 columnStatement.ColumnConstraints.Add(new UniqueConstraint { OnConflict = value.OnConflict });
             }
         }
+
+        private void AddPrimaryKeyConstraintAndAdjustTypeIfNecessary(EdmProperty property, ColumnStatement columnStatement)
+        {
+            // Only handle a single primary key this way.
+            if (keyMembers.Count() != 1 || !property.Equals(keyMembers.Single()))
+            {
+                return;
+            }
+
+            ConvertIntegerType(columnStatement);
+            var primaryKeyConstraint = new PrimaryKeyConstraint();
+            primaryKeyConstraint.Autoincrement = property.GetCustomAnnotation<AutoincrementAttribute>() != null;
+            columnStatement.ColumnConstraints.Add(primaryKeyConstraint);
+        }
+
+        private static void ConvertIntegerType(ColumnStatement columnStatement)
+        {
+            const string integerType = "INTEGER";
+            columnStatement.TypeName = columnStatement.TypeName.ToUpperInvariant() == "INT" ? integerType : columnStatement.TypeName;
+        }
     }
 }
diff --git a/SQLite.CodeFirst/Internal/Builder/CompositePrimaryKeyStatementBuilder.cs b/SQLite.CodeFirst/Internal/Builder/CompositePrimaryKeyStatementBuilder.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 CompositePrimaryKeyStatementBuilder : IStatementBuilder<CompositePrimaryKeyStatement>
+    {
+        private readonly IEnumerable<EdmMember> keyMembers;
+
+        public CompositePrimaryKeyStatementBuilder(IEnumerable<EdmMember> keyMembers)
+        {
+            this.keyMembers = keyMembers;
+        }
+
+        public CompositePrimaryKeyStatement BuildStatement()
+        {
+            return new CompositePrimaryKeyStatement(keyMembers.Select(km => km.Name));
+        }
+    }
+}
diff --git a/SQLite.CodeFirst/Internal/Builder/CreateTableStatementBuilder.cs b/SQLite.CodeFirst/Internal/Builder/CreateTableStatementBuilder.cs
@@ -3,6 +3,8 @@
 using SQLite.CodeFirst.Builder.NameCreators;
 using SQLite.CodeFirst.Statement;
 using SQLite.CodeFirst.Utility;
+using SQLite.CodeFirst.Extensions;
+using System.Linq;
 
 namespace SQLite.CodeFirst.Builder
 {
@@ -19,13 +21,22 @@ public CreateTableStatementBuilder(EntitySet entitySet, AssociationTypeContainer
 
         public CreateTableStatement BuildStatement()
         {
-            var simpleColumnCollection = new ColumnStatementCollectionBuilder(entitySet.ElementType.Properties).BuildStatement();
-            var primaryKeyStatement = new PrimaryKeyStatementBuilder(entitySet.ElementType.KeyMembers).BuildStatement();
+            var keyMembers = entitySet.ElementType.KeyMembers.Cast<EdmProperty>().ToArray();
+
+            // Only create a CompositePrimaryKeyStatement if there is a composite primary key.
+            // If there is just one key member this is handled using a constraint.
+            CompositePrimaryKeyStatement compositePrimaryKeyStatement = null;
+            if (keyMembers.Length > 1)
+            {
+                compositePrimaryKeyStatement = new CompositePrimaryKeyStatementBuilder(keyMembers).BuildStatement();
+            }
+
+            var simpleColumnCollection = new ColumnStatementCollectionBuilder(entitySet.ElementType.Properties, keyMembers).BuildStatement();
             var foreignKeyCollection = new ForeignKeyStatementBuilder(associationTypeContainer.GetAssociationTypes(entitySet.Name)).BuildStatement();
 
             var columnStatements = new List<IStatement>();
             columnStatements.AddRange(simpleColumnCollection);
-            columnStatements.Add(primaryKeyStatement);
+            columnStatements.AddIfNotNull(compositePrimaryKeyStatement);
             columnStatements.AddRange(foreignKeyCollection);
 
             return new CreateTableStatement
diff --git a/SQLite.CodeFirst/Internal/Builder/PrimaryKeyStatementBuilder.cs b/SQLite.CodeFirst/Internal/Builder/PrimaryKeyStatementBuilder.cs
diff --git a/SQLite.CodeFirst/Internal/Extensions/ListExtensions.cs b/SQLite.CodeFirst/Internal/Extensions/ListExtensions.cs
@@ -0,0 +1,17 @@
+﻿using System.Collections.Generic;
+
+namespace SQLite.CodeFirst.Extensions
+{
+    public static class ListExtensions
+    {
+        public static void AddIfNotNull<T>(this ICollection<T> list, T element)
+        {
+            if (list == null || element == null)
+            {
+                return;
+            }
+
+            list.Add(element);
+        }
+    }
+}
diff --git a/SQLite.CodeFirst/Internal/Statement/ColumnConstraint/PrimaryKeyConstraint.cs b/SQLite.CodeFirst/Internal/Statement/ColumnConstraint/PrimaryKeyConstraint.cs
@@ -0,0 +1,20 @@
+﻿using System.Text;
+
+namespace SQLite.CodeFirst.Statement.ColumnConstraint
+{
+    internal class PrimaryKeyConstraint : IColumnConstraint
+    {
+        private const string Template = "PRIMARY KEY {autoincrement}";
+
+        public bool Autoincrement { get; set; }
+
+        public string CreateStatement()
+        {
+            var sb = new StringBuilder(Template);
+
+            sb.Replace("{autoincrement}", Autoincrement ? "AUTOINCREMENT" : string.Empty);
+
+            return sb.ToString().Trim();
+        }
+    }
+}
diff --git a/SQLite.CodeFirst/Internal/Statement/CompositePrimaryKeyStatement.cs b/SQLite.CodeFirst/Internal/Statement/CompositePrimaryKeyStatement.cs
@@ -4,12 +4,12 @@
 
 namespace SQLite.CodeFirst.Statement
 {
-    internal class PrimaryKeyStatement : Collection<string>, IStatement
+    internal class CompositePrimaryKeyStatement : Collection<string>, IStatement
     {
         private const string Template = "PRIMARY KEY({primary-keys})";
         private const string PrimaryKeyColumnNameSeperator = ", ";
 
-        public PrimaryKeyStatement(IEnumerable<string> keyMembers)
+        public CompositePrimaryKeyStatement(IEnumerable<string> keyMembers)
         {
             foreach (var keyMember in keyMembers)
             {
diff --git a/SQLite.CodeFirst/Public/Attributes/AutoincrementAttribute.cs b/SQLite.CodeFirst/Public/Attributes/AutoincrementAttribute.cs
@@ -0,0 +1,24 @@
+﻿using System;
+
+namespace SQLite.CodeFirst
+{
+    /// <summary>
+    /// Decorate an primary key with this attribute to create a "INTEGER PRIMARY KEY AUTOINCREMENT" column.
+    /// <remarks>
+    /// 1. The AUTOINCREMENT keyword imposes extra CPU, memory, disk space, and disk I/O overhead and should be avoided if not
+    /// strictly needed. It is usually not needed.
+    /// 2. In SQLite, a column with type INTEGER PRIMARY KEY is an alias for the ROWID(except in WITHOUT ROWID tables) which
+    /// is always a 64-bit signed integer.
+    /// 3. On an INSERT, if the ROWID or INTEGER PRIMARY KEY column is not explicitly given a value, then it will be filled
+    /// automatically with an unused integer, usually one more than the largest ROWID currently in use.This is true
+    /// regardless of whether or not the AUTOINCREMENT keyword is used.
+    /// 4. If the AUTOINCREMENT keyword appears after INTEGER PRIMARY KEY, that changes the automatic ROWID assignment
+    /// algorithm to prevent the reuse of ROWIDs over the lifetime of the database.In other words, the purpose of
+    /// AUTOINCREMENT is to prevent the reuse of ROWIDs from previously deleted rows.
+    /// http://sqlite.org/autoinc.html [24.02.2017]
+    /// </remarks>
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Property)]
+    public sealed class AutoincrementAttribute : Attribute
+    {}
+}
diff --git a/SQLite.CodeFirst/Public/DbInitializers/SqliteInitializerBase.cs b/SQLite.CodeFirst/Public/DbInitializers/SqliteInitializerBase.cs
@@ -42,6 +42,7 @@ protected SqliteInitializerBase(DbModelBuilder modelBuilder)
             // So there are some custom attributes.
             modelBuilder.RegisterAttributeAsColumnAnnotation<UniqueAttribute>();
             modelBuilder.RegisterAttributeAsColumnAnnotation<CollateAttribute>();
+            modelBuilder.RegisterAttributeAsColumnAnnotation<AutoincrementAttribute>();
 
             // By default there is a 'ForeignKeyIndexConvention' but it can be removed.
             // And there is no "Contains" and no way to enumerate the ConventionsCollection.
diff --git a/SQLite.CodeFirst/SQLite.CodeFirst.csproj b/SQLite.CodeFirst/SQLite.CodeFirst.csproj
@@ -88,6 +88,9 @@
       <Link>Properties\AssemblySharedInfo.cs</Link>
     </Compile>
     <Compile Include="Internal\Utility\InMemoryAwareFile.cs" />
+    <Compile Include="Internal\Extensions\ListExtensions.cs" />
+    <Compile Include="Internal\Statement\ColumnConstraint\PrimaryKeyConstraint.cs" />
+    <Compile Include="Public\Attributes\AutoincrementAttribute.cs" />
     <Compile Include="Public\Attributes\CollateAttribute.cs" />
     <Compile Include="Public\Attributes\CollationFunction.cs" />
     <Compile Include="Public\Attributes\OnConflictAction.cs" />
@@ -114,15 +117,15 @@
     <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\Builder\CompositePrimaryKeyStatementBuilder.cs" />
     <Compile Include="Internal\Convention\SqliteForeignKeyIndexConvention.cs" />
     <Compile Include="Internal\Extensions\EntityTypeExtension.cs" />
     <Compile Include="Public\DbInitializers\SqliteCreateDatabaseIfNotExists.cs" />
     <Compile Include="Public\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="Internal\Statement\CompositePrimaryKeyStatement.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Internal\Utility\ConnectionStringParser.cs" />
     <Compile Include="Public\DbInitializers\SqliteInitializerBase.cs" />

Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@ namespace SQLite.CodeFirst.Console.Entity`
`6`	`6`	`{`
`7`	`7`	`public class Team : IEntity`
`8`	`8`	`{`
	`9`	`+ [Autoincrement]`
`9`	`10`	`public int Id { get; set; }`
`10`	`11`
`11`	`12`	`[Index("IX_Team_TeamsName")] // Test for named index.`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ public void CreateStatementWithOneKeyTest()`
`12`	`12`	`{`
`13`	`13`	`const string keyMember1 = "keyMember1";`
`14`	`14`
`15`		`- var primaryKeyStatement = new PrimaryKeyStatement(new List<string> { keyMember1 });`
	`15`	`+ var primaryKeyStatement = new CompositePrimaryKeyStatement(new List<string> { keyMember1 });`
`16`	`16`	`Assert.AreEqual(primaryKeyStatement.Count, 1);`
`17`	`17`	`Assert.AreEqual(primaryKeyStatement.CreateStatement(), "PRIMARY KEY(keyMember1)");`
`18`	`18`	`}`
`@@ -23,7 +23,7 @@ public void CreateStatementWithTwoKeyTest()`
`23`	`23`	`const string keyMember1 = "keyMember1";`
`24`	`24`	`const string keyMember2 = "keyMember2";`
`25`	`25`
`26`		`- var primaryKeyStatement = new PrimaryKeyStatement(new List<string> { keyMember1, keyMember2 });`
	`26`	`+ var primaryKeyStatement = new CompositePrimaryKeyStatement(new List<string> { keyMember1, keyMember2 });`
`27`	`27`	`Assert.AreEqual(primaryKeyStatement.Count, 2);`
`28`	`28`	`Assert.AreEqual(primaryKeyStatement.CreateStatement(), "PRIMARY KEY(keyMember1, keyMember2)");`
`29`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,5 @@`
`1`	`1`	`using System.Collections.Generic;`
`2`	`2`	`using System.Data.Entity.Core.Metadata.Edm;`
`3`		`-using System.Globalization;`
`4`	`3`	`using System.Linq;`
`5`	`4`	`using SQLite.CodeFirst.Extensions;`
`6`	`5`	`using SQLite.CodeFirst.Statement;`
`@@ -11,10 +10,12 @@ namespace SQLite.CodeFirst.Builder`
`11`	`10`	`internal class ColumnStatementCollectionBuilder : IStatementBuilder<ColumnStatementCollection>`
`12`	`11`	`{`
`13`	`12`	`private readonly IEnumerable<EdmProperty> properties;`
	`13`	`+ private readonly IEnumerable<EdmProperty> keyMembers;`
`14`	`14`
`15`		`- public ColumnStatementCollectionBuilder(IEnumerable<EdmProperty> properties)`
	`15`	`+ public ColumnStatementCollectionBuilder(IEnumerable<EdmProperty> properties, IEnumerable<EdmProperty> keyMembers)`
`16`	`16`	`{`
`17`	`17`	`this.properties = properties;`
	`18`	`+ this.keyMembers = keyMembers;`
`18`	`19`	`}`
`19`	`20`
`20`	`21`	`public ColumnStatementCollection BuildStatement()`
`@@ -39,6 +40,7 @@ private IEnumerable<ColumnStatement> CreateColumnStatements()`
`39`	`40`	`AddNullConstraintIfNecessary(property, columnStatement);`
`40`	`41`	`AddUniqueConstraintIfNecessary(property, columnStatement);`
`41`	`42`	`AddCollationConstraintIfNecessary(property, columnStatement);`
	`43`	`+ AddPrimaryKeyConstraintAndAdjustTypeIfNecessary(property, columnStatement);`
`42`	`44`
`43`	`45`	`yield return columnStatement;`
`44`	`46`	`}`
`@@ -57,7 +59,7 @@ private static void AdjustDatatypeForAutogenerationIfNecessary(EdmProperty prope`
`57`	`59`	`if (property.StoreGeneratedPattern == StoreGeneratedPattern.Identity)`
`58`	`60`	`{`
`59`	`61`	`// Must be INTEGER else SQLite will not generate the Ids`
`60`		`- columnStatement.TypeName = columnStatement.TypeName.ToUpperInvariant() == "INT" ? "INTEGER" : columnStatement.TypeName;`
	`62`	`+ ConvertIntegerType(columnStatement);`
`61`	`63`	`}`
`62`	`64`	`}`
`63`	`65`
`@@ -87,5 +89,25 @@ private static void AddUniqueConstraintIfNecessary(EdmProperty property, ColumnS`
`87`	`89`	`columnStatement.ColumnConstraints.Add(new UniqueConstraint { OnConflict = value.OnConflict });`
`88`	`90`	`}`
`89`	`91`	`}`
	`92`	`+`
	`93`	`+ private void AddPrimaryKeyConstraintAndAdjustTypeIfNecessary(EdmProperty property, ColumnStatement columnStatement)`
	`94`	`+ {`
	`95`	`+ // Only handle a single primary key this way.`
	`96`	`+ if (keyMembers.Count() != 1 \|\| !property.Equals(keyMembers.Single()))`
	`97`	`+ {`
	`98`	`+ return;`
	`99`	`+ }`
	`100`	`+`
	`101`	`+ ConvertIntegerType(columnStatement);`
	`102`	`+ var primaryKeyConstraint = new PrimaryKeyConstraint();`
	`103`	`+ primaryKeyConstraint.Autoincrement = property.GetCustomAnnotation<AutoincrementAttribute>() != null;`
	`104`	`+ columnStatement.ColumnConstraints.Add(primaryKeyConstraint);`
	`105`	`+ }`
	`106`	`+`
	`107`	`+ private static void ConvertIntegerType(ColumnStatement columnStatement)`
	`108`	`+ {`
	`109`	`+ const string integerType = "INTEGER";`
	`110`	`+ columnStatement.TypeName = columnStatement.TypeName.ToUpperInvariant() == "INT" ? integerType : columnStatement.TypeName;`
	`111`	`+ }`
`90`	`112`	`}`
`91`	`113`	`}`