Merge pull request msallin#62 from msallin/Issue-42

Issue 42

Author: msallin

README.md

@@ -22,7 +22,8 @@ Currently the following is supported:
 - Not Null constraint
 - Auto increment (An int PrimaryKey will automatically be incremented)
 - 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`)
-- Unique constraint (Decorate columsn with the `UniqueAttribute` which is part of this library)
+- Unique constraint (Decorate columns with the `UniqueAttribute`, which is part of this library)
+- Collate constraint (Decorate columns with the `CollateAttribute`, which is part of this library)
 
 I tried to write the code in a extensible way.
 The logic is divided into two main parts, Builder and Statement.

SQLite.CodeFirst.Console/Entity/Person.cs

@@ -7,6 +7,7 @@ public abstract class Person : IEntity
         public int Id { get; set; }
 
         [MaxLength(50)]
+        [Collate(CollationFunction.NoCase)]
         public string FirstName { get; set; }
 
         [MaxLength(50)]

SQLite.CodeFirst.Test/SQLite.CodeFirst.Test.csproj

@@ -80,6 +80,7 @@
     <Compile Include="Statement\ColumnConstraint\MaxLengthConstraint.cs" />
     <Compile Include="Statement\ColumnConstraint\ColumnConstraintCollectionTest.cs" />
     <Compile Include="Statement\ColumnConstraint\NotNullConstraintTest.cs" />
+    <Compile Include="Statement\ColumnConstraint\CollateConstraintTest.cs" />
     <Compile Include="Statement\ColumnConstraint\UniqueConstraintTest.cs" />
     <Compile Include="Statement\ColumnStatementCollectionTest.cs" />
     <Compile Include="Statement\PrimaryKeyStatementTest.cs" />

SQLite.CodeFirst.Test/Statement/ColumnConstraint/CollateConstraintTest.cs

@@ -0,0 +1,27 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using SQLite.CodeFirst.Statement.ColumnConstraint;
+
+namespace SQLite.CodeFirst.Test.Statement.ColumnConstraint
+{
+    [TestClass]
+    public class CollateConstraintTest
+    {
+        [TestMethod]
+        public void CreateStatement_StatementIsCorrect_NoConstraint()
+        {
+            var collationConstraint = new CollateConstraint();
+            collationConstraint.CollationFunction = CollationFunction.None;
+            string output = collationConstraint.CreateStatement();
+            Assert.AreEqual(output, "");
+        }
+
+        [TestMethod]
+        public void CreateStatement_StatementIsCorrect_NoCase()
+        {
+            var collationConstraint = new CollateConstraint();
+            collationConstraint.CollationFunction = CollationFunction.NoCase;
+            string output = collationConstraint.CreateStatement();
+            Assert.AreEqual(output, "COLLATE NOCASE");
+        }
+    }
+}

SQLite.CodeFirst/Attributes/CollateAttribute.cs

@@ -0,0 +1,19 @@
+using System;
+
+namespace SQLite.CodeFirst
+{
+    /// <summary>
+    /// When SQLite compares two strings, it uses a collating sequence or collating function (two words for the same thing)
+    /// to determine which string is greater or if the two strings are equal. SQLite has three built-in collating functions (see <see cref="CollationFunction"/>).
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Property)]
+    public sealed class CollateAttribute : Attribute
+    {
+        public CollateAttribute(CollationFunction collation = CollationFunction.None)
+        {
+            Collation = collation;
+        }
+
+        public CollationFunction Collation { get; set; }
+    }
+}

SQLite.CodeFirst/Attributes/CollationFunction.cs

@@ -0,0 +1,28 @@
+namespace SQLite.CodeFirst
+{
+    /// <summary>
+    /// The collation function to use for this column.
+    /// Is used together with the <see cref="CollateAttribute" />.
+    /// </summary>
+    public enum CollationFunction
+    {
+        None,
+
+        /// <summary>
+        /// Compares string data using memcmp(), regardless of text encoding.
+        /// </summary>
+        RTrim,
+
+        /// <summary>
+        /// The same as binary, except the 26 upper case characters of ASCII are folded to their lower case equivalents before
+        /// the comparison is performed. Note that only ASCII characters are case folded. SQLite does not attempt to do full
+        /// UTF case folding due to the size of the tables required.
+        /// </summary>
+        NoCase,
+
+        /// <summary>
+        /// The same as binary, except that trailing space characters are ignored.
+        /// </summary>
+        Binary
+    }
+}

SQLite.CodeFirst/DbInitializers/SqliteInitializerBase.cs

@@ -4,6 +4,7 @@
 using SQLite.CodeFirst.Convention;
 using System.IO;
 using System.Linq;
+using SQLite.CodeFirst.Extensions;
 using SQLite.CodeFirst.Utility;
 
 namespace SQLite.CodeFirst
@@ -37,9 +38,11 @@ protected SqliteInitializerBase(DbModelBuilder modelBuilder)
             // See https://github.com/msallin/SQLiteCodeFirst/issues/7 for details.
             modelBuilder.Conventions.Remove<TimestampAttributeConvention>();
 
-            modelBuilder.Properties()
-                .Having(x => x.GetCustomAttributes(false).OfType<UniqueAttribute>().FirstOrDefault())
-                .Configure((config, attribute) => config.HasColumnAnnotation("IsUnique", attribute));
+            // There is some functionality which is supported by SQLite which can not be covered
+            // by using the data annotation attributes from the .net framework.
+            // So there are some custom attributes.
+            modelBuilder.RegisterAttributeAsColumnAnnotation<UniqueAttribute>();
+            modelBuilder.RegisterAttributeAsColumnAnnotation<CollateAttribute>();
 
             // By default there is a 'ForeignKeyIndexConvention' but it can be removed.
             // And there is no "Contains" and no way to enumerate the ConventionsCollection.

SQLite.CodeFirst/Internal/Builder/ColumnStatementCollectionBuilder.cs

@@ -2,6 +2,7 @@
 using System.Data.Entity.Core.Metadata.Edm;
 using System.Globalization;
 using System.Linq;
+using SQLite.CodeFirst.Extensions;
 using SQLite.CodeFirst.Statement;
 using SQLite.CodeFirst.Statement.ColumnConstraint;
 
@@ -37,6 +38,7 @@ private IEnumerable<ColumnStatement> CreateColumnStatements()
                 AdjustDatatypeForAutogenerationIfNecessary(property, columnStatement);
                 AddNullConstraintIfNecessary(property, columnStatement);
                 AddUniqueConstraintIfNecessary(property, columnStatement);
+                AddCollationConstraintIfNecessary(property, columnStatement);
 
                 yield return columnStatement;
             }
@@ -68,17 +70,21 @@ private static void AddNullConstraintIfNecessary(EdmProperty property, ColumnSta
             }
         }
 
+        private static void AddCollationConstraintIfNecessary(EdmProperty property, ColumnStatement columnStatement)
+        {
+            var value = property.GetCustomAnnotation<CollateAttribute>();
+            if (value != null)
+            {
+                columnStatement.ColumnConstraints.Add(new CollateConstraint { CollationFunction = value.Collation });
+            }
+        }
+
         private static void AddUniqueConstraintIfNecessary(EdmProperty property, ColumnStatement columnStatement)
         {
-            MetadataProperty item;
-            bool found = property.MetadataProperties.TryGetValue("http://schemas.microsoft.com/ado/2013/11/edm/customannotation:IsUnique", true, out item);
-            if (found)
+            var value = property.GetCustomAnnotation<UniqueAttribute>();
+            if (value != null)
             {
-                var value = (UniqueAttribute)item.Value;
-                columnStatement.ColumnConstraints.Add(new UniqueConstraint
-                {
-                    OnConflict = value.OnConflict
-                });
+                columnStatement.ColumnConstraints.Add(new UniqueConstraint { OnConflict = value.OnConflict });
             }
         }
     }

SQLite.CodeFirst/Internal/Extensions/DbModelBuilderExtensions.cs

@@ -0,0 +1,16 @@
+using System.Data.Entity;
+using System.Linq;
+
+namespace SQLite.CodeFirst.Extensions
+{
+    internal static class DbModelBuilderExtensions
+    {
+        public static void RegisterAttributeAsColumnAnnotation<TAttribute>(this DbModelBuilder modelBuilder)
+            where TAttribute : class
+        {
+            modelBuilder.Properties()
+                .Having(x => x.GetCustomAttributes(false).OfType<TAttribute>().FirstOrDefault())
+                .Configure((config, attribute) => config.HasColumnAnnotation(typeof(TAttribute).Name, attribute));
+        }
+    }
+}

SQLite.CodeFirst/Internal/Extensions/EdmPropertyExtensions.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Data.Entity.Core.Metadata.Edm;
+
+namespace SQLite.CodeFirst.Extensions
+{
+    internal static class EdmPropertyExtensions
+    {
+        public static TAttribute GetCustomAnnotation<TAttribute>(this EdmProperty property)
+            where TAttribute : Attribute
+        {
+            MetadataProperty item;
+            bool found = property.MetadataProperties.TryGetValue("http://schemas.microsoft.com/ado/2013/11/edm/customannotation:" + typeof(TAttribute).Name, true, out item);
+            if (found)
+            {
+                return (TAttribute) item.Value;
+            }
+
+            return null;
+        }
+    }
+}