42: Use CollateConstraint and refactoring to make it easier to use attributes as custom annotations.

Author: Marc Sallin

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

SQLite.CodeFirst/SQLite.CodeFirst.csproj

@@ -91,6 +91,8 @@
     <Compile Include="Internal\Builder\NameCreators\IndexNameCreator.cs" />
     <Compile Include="Internal\Builder\NameCreators\SpecialChars.cs" />
     <Compile Include="IDatabaseCreator.cs" />
+    <Compile Include="Internal\Extensions\DbModelBuilderExtensions.cs" />
+    <Compile Include="Internal\Extensions\EdmPropertyExtensions.cs" />
     <Compile Include="Internal\Statement\ColumnConstraint\CollateConstraint.cs" />
     <Compile Include="Internal\Statement\ColumnConstraint\UniqueConstraint.cs" />
     <Compile Include="Internal\Utility\HashCreator.cs" />