#107: escape columnName to avoid reserved keyword conflict

Kizzzy · msallin · commit ed11c32e9bfa · 2021-04-23T11:41:15.000+02:00
diff --git a/SQLite.CodeFirst.Test/IntegrationTests/SqlGenerationTest.cs b/SQLite.CodeFirst.Test/IntegrationTests/SqlGenerationTest.cs
@@ -1,5 +1,4 @@
-﻿using System;
-using System.Data.Common;
+﻿using System.Data.Common;
 using System.Data.Entity;
 using System.Data.Entity.Infrastructure;
 using System.Data.SQLite;
@@ -14,18 +13,19 @@ namespace SQLite.CodeFirst.Test.IntegrationTests
     public class SqlGenerationTest
     {
         private const string ReferenceSql =
-            @"CREATE TABLE ""MyTable"" ([Id] INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, [Name] nvarchar NOT NULL, FOREIGN KEY (Id) REFERENCES ""Coaches""(Id));
+            @"
+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, [CreatedUtc] datetime NOT NULL DEFAULT (DATETIME('now')));
-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, [CreatedUtc] datetime NOT NULL DEFAULT (DATETIME('now')), [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, [Order] int 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 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 TABLE ""FooCompositeKeys"" ([Id] int NOT NULL, [Version] nvarchar (20) NOT NULL, [Name] nvarchar (255), PRIMARY KEY(Id, Version));
+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, [CreatedUtc] datetime NOT NULL DEFAULT (DATETIME('now')), [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, [Order] int 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 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 TABLE ""FooCompositeKeys"" ([Id] int NOT NULL, [Version] nvarchar (20) NOT NULL, [Name] nvarchar (255), PRIMARY KEY([Id], [Version]));
 CREATE TABLE ""FooRelationshipAs"" ([Id] INTEGER PRIMARY KEY, [Name] nvarchar (255));
 CREATE TABLE ""FooRelationshipBs"" ([Id] INTEGER PRIMARY KEY, [Name] nvarchar (255));
-CREATE TABLE ""FooRelationshipAFooCompositeKeys"" ([FooRelationshipA_Id] int NOT NULL, [FooCompositeKey_Id] int NOT NULL, [FooCompositeKey_Version] nvarchar (20) NOT NULL, PRIMARY KEY(FooRelationshipA_Id, FooCompositeKey_Id, FooCompositeKey_Version), FOREIGN KEY (FooRelationshipA_Id) REFERENCES ""FooRelationshipAs""(Id) ON DELETE CASCADE, FOREIGN KEY (FooCompositeKey_Id, FooCompositeKey_Version) REFERENCES ""FooCompositeKeys""(Id, Version) ON DELETE CASCADE);
-CREATE TABLE ""FooRelationshipBFooCompositeKeys"" ([FooRelationshipB_Id] int NOT NULL, [FooCompositeKey_Id] int NOT NULL, [FooCompositeKey_Version] nvarchar (20) NOT NULL, PRIMARY KEY(FooRelationshipB_Id, FooCompositeKey_Id, FooCompositeKey_Version), FOREIGN KEY (FooRelationshipB_Id) REFERENCES ""FooRelationshipBs""(Id) ON DELETE CASCADE, FOREIGN KEY (FooCompositeKey_Id, FooCompositeKey_Version) REFERENCES ""FooCompositeKeys""(Id, Version) ON DELETE CASCADE);
+CREATE TABLE ""FooRelationshipAFooCompositeKeys"" ([FooRelationshipA_Id] int NOT NULL, [FooCompositeKey_Id] int NOT NULL, [FooCompositeKey_Version] nvarchar (20) NOT NULL, PRIMARY KEY([FooRelationshipA_Id], [FooCompositeKey_Id], [FooCompositeKey_Version]), FOREIGN KEY ([FooRelationshipA_Id]) REFERENCES ""FooRelationshipAs""([Id]) ON DELETE CASCADE, FOREIGN KEY ([FooCompositeKey_Id], [FooCompositeKey_Version]) REFERENCES ""FooCompositeKeys""([Id], [Version]) ON DELETE CASCADE);
+CREATE TABLE ""FooRelationshipBFooCompositeKeys"" ([FooRelationshipB_Id] int NOT NULL, [FooCompositeKey_Id] int NOT NULL, [FooCompositeKey_Version] nvarchar (20) NOT NULL, PRIMARY KEY([FooRelationshipB_Id], [FooCompositeKey_Id], [FooCompositeKey_Version]), FOREIGN KEY ([FooRelationshipB_Id]) REFERENCES ""FooRelationshipBs""([Id]) ON DELETE CASCADE, FOREIGN KEY ([FooCompositeKey_Id], [FooCompositeKey_Version]) REFERENCES ""FooCompositeKeys""([Id], [Version]) ON DELETE CASCADE);
 CREATE  INDEX ""IX_MyTable_Id"" ON ""MyTable"" (""Id"");
 CREATE  INDEX ""IX_Team_TeamsName"" ON ""MyTable"" (""Name"");
 CREATE  INDEX ""IX_TeamPlayer_Number"" ON ""TeamPlayer"" (""Number"");
@@ -42,12 +42,13 @@ public class SqlGenerationTest
 CREATE  INDEX ""IX_FooRelationshipAFooCompositeKey_FooRelationshipA_Id"" ON ""FooRelationshipAFooCompositeKeys"" (""FooRelationshipA_Id"");
 CREATE  INDEX ""IX_FooRelationshipAFooCompositeKey_FooCompositeKey_Id_FooCompositeKey_Version"" ON ""FooRelationshipAFooCompositeKeys"" (""FooCompositeKey_Id"", ""FooCompositeKey_Version"");
 CREATE  INDEX ""IX_FooRelationshipBFooCompositeKey_FooRelationshipB_Id"" ON ""FooRelationshipBFooCompositeKeys"" (""FooRelationshipB_Id"");
-CREATE  INDEX ""IX_FooRelationshipBFooCompositeKey_FooCompositeKey_Id_FooCompositeKey_Version"" ON ""FooRelationshipBFooCompositeKeys"" (""FooCompositeKey_Id"", ""FooCompositeKey_Version"");";
+CREATE  INDEX ""IX_FooRelationshipBFooCompositeKey_FooCompositeKey_Id_FooCompositeKey_Version"" ON ""FooRelationshipBFooCompositeKeys"" (""FooCompositeKey_Id"", ""FooCompositeKey_Version"");
+";
 
         private static string generatedSql;
 
         // Does not work on the build server. No clue why.
-        
+
         [TestMethod]
         public void SqliteSqlGeneratorTest()
         {
diff --git a/SQLite.CodeFirst.Test/UnitTests/Statement/ColumnStatementTest.cs b/SQLite.CodeFirst.Test/UnitTests/Statement/ColumnStatementTest.cs
@@ -16,9 +16,9 @@ public void CreateStatement()
 
             var columnStatement = new ColumnStatement
             {
-                ColumnConstraints = columnConstraintsMock.Object,
                 ColumnName = "dummyColumnName",
-                TypeName = "dummyType"
+                TypeName = "dummyType",
+                ColumnConstraints = columnConstraintsMock.Object,
             };
             string output = columnStatement.CreateStatement();
             Assert.AreEqual(output, "[dummyColumnName] dummyType dummyColumnConstraint");
diff --git a/SQLite.CodeFirst.Test/UnitTests/Statement/ForeignKeyStatementTest.cs b/SQLite.CodeFirst.Test/UnitTests/Statement/ForeignKeyStatementTest.cs
@@ -19,7 +19,7 @@ public void CreateStatementOneForeignKeyTest()
             };
 
             string output = foreignKeyStatement.CreateStatement();
-            Assert.AreEqual(output, "FOREIGN KEY (dummyForeignKey1) REFERENCES dummyForeignTable(dummForeignPrimaryKey1)");
+            Assert.AreEqual(output, "FOREIGN KEY ([dummyForeignKey1]) REFERENCES dummyForeignTable([dummForeignPrimaryKey1])");
         }
 
         [TestMethod]
@@ -34,7 +34,7 @@ public void CreateStatementOneForeignKeyCascadeDeleteTest()
             };
 
             string output = foreignKeyStatement.CreateStatement();
-            Assert.AreEqual(output, "FOREIGN KEY (dummyForeignKey1) REFERENCES dummyForeignTable(dummForeignPrimaryKey1) ON DELETE CASCADE");
+            Assert.AreEqual(output, "FOREIGN KEY ([dummyForeignKey1]) REFERENCES dummyForeignTable([dummForeignPrimaryKey1]) ON DELETE CASCADE");
         }
 
         [TestMethod]
@@ -49,7 +49,7 @@ public void CreateStatementTwoForeignKeyTest()
             };
 
             string output = foreignKeyStatement.CreateStatement();
-            Assert.AreEqual(output, "FOREIGN KEY (dummyForeignKey1, dummyForeignKey2) REFERENCES dummyForeignTable(dummForeignPrimaryKey1)");
+            Assert.AreEqual(output, "FOREIGN KEY ([dummyForeignKey1], [dummyForeignKey2]) REFERENCES dummyForeignTable([dummForeignPrimaryKey1])");
         }
 
         [TestMethod]
@@ -64,7 +64,7 @@ public void CreateStatementTwoForeignKeyTwoPrimaryKeyTest()
             };
 
             string output = foreignKeyStatement.CreateStatement();
-            Assert.AreEqual(output, "FOREIGN KEY (dummyForeignKey1, dummyForeignKey2) REFERENCES dummyForeignTable(dummForeignPrimaryKey1, dummForeignPrimaryKey2)");
+            Assert.AreEqual(output, "FOREIGN KEY ([dummyForeignKey1], [dummyForeignKey2]) REFERENCES dummyForeignTable([dummForeignPrimaryKey1], [dummForeignPrimaryKey2])");
         }
 
         [TestMethod]
@@ -79,7 +79,7 @@ public void CreateStatementOneForeignKeyTwoPrimaryKeyTest()
             };
 
             string output = foreignKeyStatement.CreateStatement();
-            Assert.AreEqual(output, "FOREIGN KEY (dummyForeignKey1) REFERENCES dummyForeignTable(dummForeignPrimaryKey1, dummForeignPrimaryKey2)");
+            Assert.AreEqual(output, "FOREIGN KEY ([dummyForeignKey1]) REFERENCES dummyForeignTable([dummForeignPrimaryKey1], [dummForeignPrimaryKey2])");
         }
     }
 }
diff --git a/SQLite.CodeFirst.Test/UnitTests/Statement/PrimaryKeyStatementTest.cs b/SQLite.CodeFirst.Test/UnitTests/Statement/PrimaryKeyStatementTest.cs
@@ -14,7 +14,7 @@ public void CreateStatementWithOneKeyTest()
 
             var primaryKeyStatement = new CompositePrimaryKeyStatement(new List<string> { keyMember1 });
             Assert.AreEqual(primaryKeyStatement.Count, 1);
-            Assert.AreEqual(primaryKeyStatement.CreateStatement(), "PRIMARY KEY(keyMember1)");
+            Assert.AreEqual(primaryKeyStatement.CreateStatement(), "PRIMARY KEY([keyMember1])");
         }
 
         [TestMethod]
@@ -25,7 +25,7 @@ public void CreateStatementWithTwoKeyTest()
 
             var primaryKeyStatement = new CompositePrimaryKeyStatement(new List<string> { keyMember1, keyMember2 });
             Assert.AreEqual(primaryKeyStatement.Count, 2);
-            Assert.AreEqual(primaryKeyStatement.CreateStatement(), "PRIMARY KEY(keyMember1, keyMember2)");
+            Assert.AreEqual(primaryKeyStatement.CreateStatement(), "PRIMARY KEY([keyMember1], [keyMember2])");
         }
     }
 }
diff --git a/SQLite.CodeFirst/Internal/Builder/NameCreators/ColumnNameCreator.cs b/SQLite.CodeFirst/Internal/Builder/NameCreators/ColumnNameCreator.cs
@@ -0,0 +1,12 @@
+﻿using System.Globalization;
+
+namespace SQLite.CodeFirst.Builder.NameCreators
+{
+    internal static class ColumnNameCreator
+    {
+        public static string EscapeName(string columnName)
+        {
+            return string.Format(CultureInfo.InvariantCulture, "[{0}]", columnName);
+        }
+    }
+}
diff --git a/SQLite.CodeFirst/Internal/Statement/ColumnStatement.cs b/SQLite.CodeFirst/Internal/Statement/ColumnStatement.cs
@@ -1,11 +1,12 @@
 ﻿using System.Text;
+using SQLite.CodeFirst.Builder.NameCreators;
 using SQLite.CodeFirst.Statement.ColumnConstraint;
 
 namespace SQLite.CodeFirst.Statement
 {
     internal class ColumnStatement : IStatement
     {
-        private const string Template = "[{column-name}] {type-name} {column-constraint}";
+        private const string Template = "{column-name} {type-name} {column-constraint}";
 
         public string ColumnName { get; set; }
         public string TypeName { get; set; }
@@ -15,7 +16,7 @@ public string CreateStatement()
         {
             var sb = new StringBuilder(Template);
 
-            sb.Replace("{column-name}", ColumnName);
+            sb.Replace("{column-name}", ColumnNameCreator.EscapeName(ColumnName));
             sb.Replace("{type-name}", TypeName);
             sb.Replace("{column-constraint}", ColumnConstraints.CreateStatement());
 
diff --git a/SQLite.CodeFirst/Internal/Statement/CompositePrimaryKeyStatement.cs b/SQLite.CodeFirst/Internal/Statement/CompositePrimaryKeyStatement.cs
@@ -1,13 +1,14 @@
-﻿using System;
+﻿using SQLite.CodeFirst.Builder.NameCreators;
+using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Linq;
 
 namespace SQLite.CodeFirst.Statement
 {
     internal class CompositePrimaryKeyStatement : Collection<string>, IStatement
     {
         private const string Template = "PRIMARY KEY({primary-keys})";
-        private const string PrimaryKeyColumnNameSeperator = ", ";
 
         public CompositePrimaryKeyStatement(IEnumerable<string> keyMembers)
         {
@@ -19,7 +20,7 @@ public CompositePrimaryKeyStatement(IEnumerable<string> keyMembers)
 
         public string CreateStatement()
         {
-            string primaryKeys = String.Join(PrimaryKeyColumnNameSeperator, this);
+            string primaryKeys = String.Join(", ", this.Select(c => ColumnNameCreator.EscapeName(c)));
             return Template.Replace("{primary-keys}", primaryKeys);
         }
     }
diff --git a/SQLite.CodeFirst/Internal/Statement/ForeignKeyStatement.cs b/SQLite.CodeFirst/Internal/Statement/ForeignKeyStatement.cs
@@ -1,4 +1,6 @@
-﻿using System.Collections.Generic;
+﻿using SQLite.CodeFirst.Builder.NameCreators;
+using System.Collections.Generic;
+using System.Linq;
 using System.Text;
 
 namespace SQLite.CodeFirst.Statement
@@ -16,11 +18,9 @@ internal class ForeignKeyStatement : IStatement
         public string CreateStatement()
         {
             var sb = new StringBuilder(Template);
-
-            sb.Replace("{foreign-key}", string.Join(", ", ForeignKey));
+            sb.Replace("{foreign-key}", string.Join(", ", ForeignKey.Select(c => ColumnNameCreator.EscapeName(c))));
             sb.Replace("{referenced-table}", ForeignTable);
-            sb.Replace("{referenced-id}", string.Join(", ", ForeignPrimaryKey));
-
+            sb.Replace("{referenced-id}", string.Join(", ", ForeignPrimaryKey.Select(c => ColumnNameCreator.EscapeName(c))));
             if (CascadeDelete)
             {
                 sb.Append(" " + CascadeDeleteStatement);

Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ public void CreateStatementOneForeignKeyTest()`
`19`	`19`	`};`
`20`	`20`
`21`	`21`	`string output = foreignKeyStatement.CreateStatement();`
`22`		`- Assert.AreEqual(output, "FOREIGN KEY (dummyForeignKey1) REFERENCES dummyForeignTable(dummForeignPrimaryKey1)");`
	`22`	`+ Assert.AreEqual(output, "FOREIGN KEY ([dummyForeignKey1]) REFERENCES dummyForeignTable([dummForeignPrimaryKey1])");`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`[TestMethod]`
`@@ -34,7 +34,7 @@ public void CreateStatementOneForeignKeyCascadeDeleteTest()`
`34`	`34`	`};`
`35`	`35`
`36`	`36`	`string output = foreignKeyStatement.CreateStatement();`
`37`		`- Assert.AreEqual(output, "FOREIGN KEY (dummyForeignKey1) REFERENCES dummyForeignTable(dummForeignPrimaryKey1) ON DELETE CASCADE");`
	`37`	`+ Assert.AreEqual(output, "FOREIGN KEY ([dummyForeignKey1]) REFERENCES dummyForeignTable([dummForeignPrimaryKey1]) ON DELETE CASCADE");`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`[TestMethod]`
`@@ -49,7 +49,7 @@ public void CreateStatementTwoForeignKeyTest()`
`49`	`49`	`};`
`50`	`50`
`51`	`51`	`string output = foreignKeyStatement.CreateStatement();`
`52`		`- Assert.AreEqual(output, "FOREIGN KEY (dummyForeignKey1, dummyForeignKey2) REFERENCES dummyForeignTable(dummForeignPrimaryKey1)");`
	`52`	`+ Assert.AreEqual(output, "FOREIGN KEY ([dummyForeignKey1], [dummyForeignKey2]) REFERENCES dummyForeignTable([dummForeignPrimaryKey1])");`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`[TestMethod]`
`@@ -64,7 +64,7 @@ public void CreateStatementTwoForeignKeyTwoPrimaryKeyTest()`
`64`	`64`	`};`
`65`	`65`
`66`	`66`	`string output = foreignKeyStatement.CreateStatement();`
`67`		`- Assert.AreEqual(output, "FOREIGN KEY (dummyForeignKey1, dummyForeignKey2) REFERENCES dummyForeignTable(dummForeignPrimaryKey1, dummForeignPrimaryKey2)");`
	`67`	`+ Assert.AreEqual(output, "FOREIGN KEY ([dummyForeignKey1], [dummyForeignKey2]) REFERENCES dummyForeignTable([dummForeignPrimaryKey1], [dummForeignPrimaryKey2])");`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`[TestMethod]`
`@@ -79,7 +79,7 @@ public void CreateStatementOneForeignKeyTwoPrimaryKeyTest()`
`79`	`79`	`};`
`80`	`80`
`81`	`81`	`string output = foreignKeyStatement.CreateStatement();`
`82`		`- Assert.AreEqual(output, "FOREIGN KEY (dummyForeignKey1) REFERENCES dummyForeignTable(dummForeignPrimaryKey1, dummForeignPrimaryKey2)");`
	`82`	`+ Assert.AreEqual(output, "FOREIGN KEY ([dummyForeignKey1]) REFERENCES dummyForeignTable([dummForeignPrimaryKey1], [dummForeignPrimaryKey2])");`
`83`	`83`	`}`
`84`	`84`	`}`
`85`	`85`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ public void CreateStatementWithOneKeyTest()`
`14`	`14`
`15`	`15`	`var primaryKeyStatement = new CompositePrimaryKeyStatement(new List<string> { keyMember1 });`
`16`	`16`	`Assert.AreEqual(primaryKeyStatement.Count, 1);`
`17`		`- Assert.AreEqual(primaryKeyStatement.CreateStatement(), "PRIMARY KEY(keyMember1)");`
	`17`	`+ Assert.AreEqual(primaryKeyStatement.CreateStatement(), "PRIMARY KEY([keyMember1])");`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`[TestMethod]`
`@@ -25,7 +25,7 @@ public void CreateStatementWithTwoKeyTest()`
`25`	`25`
`26`	`26`	`var primaryKeyStatement = new CompositePrimaryKeyStatement(new List<string> { keyMember1, keyMember2 });`
`27`	`27`	`Assert.AreEqual(primaryKeyStatement.Count, 2);`
`28`		`- Assert.AreEqual(primaryKeyStatement.CreateStatement(), "PRIMARY KEY(keyMember1, keyMember2)");`
	`28`	`+ Assert.AreEqual(primaryKeyStatement.CreateStatement(), "PRIMARY KEY([keyMember1], [keyMember2])");`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,12 @@`
`1`	`1`	`using System.Text;`
	`2`	`+using SQLite.CodeFirst.Builder.NameCreators;`
`2`	`3`	`using SQLite.CodeFirst.Statement.ColumnConstraint;`
`3`	`4`
`4`	`5`	`namespace SQLite.CodeFirst.Statement`
`5`	`6`	`{`
`6`	`7`	`internal class ColumnStatement : IStatement`
`7`	`8`	`{`
`8`		`- private const string Template = "[{column-name}] {type-name} {column-constraint}";`
	`9`	`+ private const string Template = "{column-name} {type-name} {column-constraint}";`
`9`	`10`
`10`	`11`	`public string ColumnName { get; set; }`
`11`	`12`	`public string TypeName { get; set; }`
`@@ -15,7 +16,7 @@ public string CreateStatement()`
`15`	`16`	`{`
`16`	`17`	`var sb = new StringBuilder(Template);`
`17`	`18`
`18`		`- sb.Replace("{column-name}", ColumnName);`
	`19`	`+ sb.Replace("{column-name}", ColumnNameCreator.EscapeName(ColumnName));`
`19`	`20`	`sb.Replace("{type-name}", TypeName);`
`20`	`21`	`sb.Replace("{column-constraint}", ColumnConstraints.CreateStatement());`
`21`	`22`
Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,14 @@`
`1`		`-using System;`
	`1`	`+using SQLite.CodeFirst.Builder.NameCreators;`
	`2`	`+using System;`
`2`	`3`	`using System.Collections.Generic;`
`3`	`4`	`using System.Collections.ObjectModel;`
	`5`	`+using System.Linq;`
`4`	`6`
`5`	`7`	`namespace SQLite.CodeFirst.Statement`
`6`	`8`	`{`
`7`	`9`	`internal class CompositePrimaryKeyStatement : Collection<string>, IStatement`
`8`	`10`	`{`
`9`	`11`	`private const string Template = "PRIMARY KEY({primary-keys})";`
`10`		`- private const string PrimaryKeyColumnNameSeperator = ", ";`
`11`	`12`
`12`	`13`	`public CompositePrimaryKeyStatement(IEnumerable<string> keyMembers)`
`13`	`14`	`{`
`@@ -19,7 +20,7 @@ public CompositePrimaryKeyStatement(IEnumerable<string> keyMembers)`
`19`	`20`
`20`	`21`	`public string CreateStatement()`
`21`	`22`	`{`
`22`		`- string primaryKeys = String.Join(PrimaryKeyColumnNameSeperator, this);`
	`23`	`+ string primaryKeys = String.Join(", ", this.Select(c => ColumnNameCreator.EscapeName(c)));`
`23`	`24`	`return Template.Replace("{primary-keys}", primaryKeys);`
`24`	`25`	`}`
`25`	`26`	`}`