Support for the "MaxLength" annotation.

Author: msallin

README.md

@@ -5,11 +5,12 @@ This Project ships a `SqliteContextInitializer` which creates a new SQLite Datab
 I started with the [code](https://gist.github.com/flaub/1968486e1b3f2b9fddaf) from [flaub](https://github.com/flaub). 
 
 Currently the following is supported:
-- Tables from classes (with table annotation)
-- Columns from properties (with key annotation)
-- Auto increment (An int PrimaryKey will automatically be incremented)
+- Tables from classes (supported annotations: `Table`)
+- Columns from properties (supported annotations: `Column`, `Key`, `MaxLength`, `Required`)
+- PrimaryKey constraint (`Key` annotation, key composites are supported)
 - ForeignKey constraint (1-n relationships, support for 'Cascade on delete')
 - Not Null constraint
+- Auto increment (An int PrimaryKey will automatically be incremented)
 
 I tried to write the code in a extensible way.
 The logic is devided into two main parts. Builder and Statement.

SQLite.CodeFirst.Console/Entity/Player.cs

@@ -6,11 +6,15 @@ namespace SQLite.CodeFirst.Console.Entity
     public class Player
     {
         [Key]
-        [Column(Order = 1)] 
+        [Column(Order = 1)]
         public string FirstName { get; set; }
         [Key]
-        [Column(Order = 2)] 
+        [Column(Order = 2)]
         public string LastName { get; set; }
+        [MaxLength(100)]
+        public string Street { get; set; }
+        [Required]
+        public string City { get; set; }
         public Team Team { get; set; }
     }
 }

SQLite.CodeFirst.Console/TestDbContext.cs

@@ -30,8 +30,6 @@ private static void ConfigurePlayerEntity(DbModelBuilder modelBuilder)
         {
             modelBuilder.RegisterEntityType(typeof(Player));
 
-            modelBuilder.Entity<Player>().Property(player => player.FirstName).HasMaxLength(10);
-
             modelBuilder.Entity<Player>().ToTable("TeamPlayer");
 
             modelBuilder.Entity<Player>()

SQLite.CodeFirst/Builder/ColumnStatementCollectionBuilder.cs

@@ -32,13 +32,22 @@ private IEnumerable<ColumnStatement> CreateColumnStatements()
                     ColumnConstraints = new ColumnConstraintCollection()
                 };
 
+                AddMaxLengthConstraintIfNecessary(property, columnStatement);
                 AdjustDatatypeForAutogenerationIfNecessary(property, columnStatement);
                 AddNullConstraintIfNecessary(property, columnStatement);
 
                 yield return columnStatement;
             }
         }
 
+        private void AddMaxLengthConstraintIfNecessary(EdmProperty property, ColumnStatement columnStatement)
+        {
+            if (property.MaxLength.HasValue)
+            {
+                columnStatement.ColumnConstraints.Add(new MaxLengthConstraint(property.MaxLength.Value));
+            }
+        }
+
         private static void AdjustDatatypeForAutogenerationIfNecessary(EdmProperty property, ColumnStatement columnStatement)
         {
             if (property.StoreGeneratedPattern == StoreGeneratedPattern.Identity)

SQLite.CodeFirst/SQLite.CodeFirst.csproj

@@ -53,6 +53,7 @@
     <Compile Include="Builder\ForeignKeyStatementBuilder.cs" />
     <Compile Include="Builder\CreateDatabaseStatementBuilder.cs" />
     <Compile Include="Builder\PrimaryKeyStatementBuilder.cs" />
+    <Compile Include="Statement\ColumnConstraint\MaxLengthConstraint.cs" />
     <Compile Include="Statement\PrimaryKeyStatement.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="SqliteConnectionStringParser.cs" />
@@ -69,7 +70,6 @@
     <Compile Include="Statement\CreateTableStatement.cs" />
     <Compile Include="Statement\IStatement.cs" />
     <Compile Include="Builder\CreateTableStatementBuilder.cs" />
-    <Compile Include="Statement\ColumnConstraint\PrimaryKeyConstraint.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />

SQLite.CodeFirst/Statement/ColumnConstraint/MaxLengthConstraint.cs

@@ -0,0 +1,28 @@
+using System;
+
+namespace SQLite.CodeFirst.Statement.ColumnConstraint
+{
+    internal class MaxLengthConstraint : IColumnConstraint
+    {
+        private const string Template = "({max-length})";
+
+        public int? MaxLength { get; set; }
+
+        public MaxLengthConstraint() { }
+
+        public MaxLengthConstraint(int maxLength)
+        {
+            MaxLength = maxLength;
+        }
+
+        public string CreateStatement()
+        {
+            if (MaxLength == null)
+            {
+                throw new InvalidOperationException("MaxLength must not be null!");
+            }
+
+            return Template.Replace("{max-length}", MaxLength.ToString());
+        }
+    }
+}