Merge pull request #497 from ServiceStack/nullable-enum-int

MySQL issue with nullable enum + int casting prob

Author: mythz

src/ServiceStack.OrmLite.MySql.Tests/EnumTests.cs

@@ -1,5 +1,6 @@
 using System.Linq;
 using NUnit.Framework;
+using ServiceStack.DataAnnotations;
 
 namespace ServiceStack.OrmLite.MySql.Tests
 {
@@ -35,6 +36,36 @@ public void CanGetEnumValue()
             }
         }
 
+        [Test]
+        public void CanCreateTableNullableEnum()
+        {
+            OpenDbConnection().CreateTable<TypeWithNullableEnum>(true);
+        }
+
+        [Test]
+        public void CanStoreNullableEnumValue()
+        {
+            using (var con = OpenDbConnection())
+            {
+                con.CreateTable<TypeWithNullableEnum>(true);
+                con.Save(new TypeWithNullableEnum { Id = 1, EnumValue = SomeEnum.Value1 });
+            }
+        }
+
+        [Test]
+        public void CanGetNullableEnumValue()
+        {
+            using (var con = OpenDbConnection())
+            {
+                con.CreateTable<TypeWithNullableEnum>(true);
+                var obj = new TypeWithNullableEnum { Id = 1, EnumValue = SomeEnum.Value1 };
+                con.Save(obj);
+                var target = con.SingleById<TypeWithNullableEnum>(obj.Id);
+                Assert.AreEqual(obj.Id, target.Id);
+                Assert.AreEqual(obj.EnumValue, target.EnumValue);
+            }
+        }
+
         [Test]
         public void CanQueryByEnumValue_using_select_with_expression()
         {
@@ -82,6 +113,72 @@ public void CanQueryByEnumValue_using_where_with_AnonType()
                 Assert.AreEqual(2, target.Count());
             }
         }
+
+        [Test]
+        public void CanQueryByNullableEnumValue_using_where_with_AnonType()
+        {
+            using (var con = OpenDbConnection())
+            {
+                con.CreateTable<TypeWithEnum>(true);
+                con.Save(new TypeWithNullableEnum { Id = 1, EnumValue = SomeEnum.Value1, IntEnum = SomeIntEnum.One });
+                con.Save(new TypeWithNullableEnum { Id = 2, EnumValue = SomeEnum.Value1, IntEnum = SomeIntEnum.One });
+                con.Save(new TypeWithNullableEnum { Id = 3, EnumValue = SomeEnum.Value2, IntEnum = SomeIntEnum.Two });
+
+                var target = con.Where<TypeWithNullableEnum>(new { EnumValue = SomeEnum.Value1 });
+                var enumInt = con.Where<TypeWithNullableEnum>(new {IntEnum = SomeIntEnum.One});
+
+                Assert.AreEqual(2, target.Count);
+                Assert.AreEqual(2, enumInt.Count);
+            }
+        }
+
+        [Test]
+        public void CanSaveNullableEnum_with_specific_id_select_with_anon_type()
+        {
+            using (var con = OpenDbConnection())
+            {
+                con.CreateTableIfNotExists<MyObj>();
+                var myObj = new MyObj();
+                myObj.Id = 1;
+                myObj.Test = MyEnum.One;
+                con.Insert(myObj);
+
+                myObj = con.Single<MyObj>(new {Id = 1});
+
+                Assert.That(myObj.Id, Is.EqualTo(1));
+                Assert.That(myObj.Test, Is.Not.EqualTo(null));
+                Assert.That(myObj.Test, Is.EqualTo(MyEnum.One));
+            }
+        }
+
+        [Test]
+        public void CanSaveNullableEnum_with_specific_id_select_with_type()
+        {
+            using (var existsCon = OpenDbConnection())
+            {
+                existsCon.CreateTableIfNotExists<MyObj>();
+                var exists = existsCon.SingleById<MyObj>(1);
+                if (exists != null)
+                {
+                    existsCon.DeleteById<MyObj>(1);
+                }
+            }
+
+            using (var con = OpenDbConnection())
+            {
+
+                var myObj = new MyObj();
+                myObj.Id = 1;
+                myObj.Test = MyEnum.One;
+                con.Insert(myObj);
+
+                myObj = con.Single<MyObj>(x => x.Id == 1);
+
+                Assert.That(myObj.Id, Is.EqualTo(1));
+                Assert.That(myObj.Test, Is.Not.EqualTo(null));
+                Assert.That(myObj.Test, Is.EqualTo(MyEnum.One));
+            }
+        }
     }
 
     public enum SomeEnum : long
@@ -91,9 +188,38 @@ public enum SomeEnum : long
         Value3
     }
 
+    [EnumAsInt]
+    public enum SomeIntEnum
+    {
+        Zero = 0,
+        One = 1,
+        Two = 2
+    }
+
+    [EnumAsInt]
+    public enum MyEnum : int
+    {
+        Zero = 0,
+        One = 1
+    }
+
+    public class MyObj
+    {
+        public int Id { get; set; }
+        public MyEnum? Test { get; set; }
+    }
+
     public class TypeWithEnum
     {
         public int Id { get; set; }
-        public SomeEnum EnumValue { get; set; } 
+        public SomeEnum EnumValue { get; set; }
+        public SomeIntEnum IntEnum { get; set; }
+    }
+	
+	public class TypeWithNullableEnum
+    {
+        public int Id { get; set; }
+        public SomeEnum? EnumValue { get; set; }
+        public SomeIntEnum? IntEnum { get; set; }
     }
 }

src/ServiceStack.OrmLite/OrmLiteWriteCommandExtensions.cs

@@ -341,7 +341,16 @@ public static T PopulateWithSqlReader<T>(this T objWithProperties,
                         else
                         {
                             var fieldValue = converter.FromDbValue(fieldDef.FieldType, value);
-                            fieldDef.SetValueFn(objWithProperties, fieldValue);
+                            if (fieldDef.FieldType.IsEnum && fieldDef.IsNullable)
+                            {
+                                var enumType = Nullable.GetUnderlyingType(fieldDef.PropertyInfo.PropertyType);
+                                var enumValue = Enum.ToObject(enumType, value);
+                                fieldDef.PropertyInfo.SetProperty(objWithProperties, enumValue);
+                            }
+                            else
+                            {
+                                fieldDef.SetValueFn(objWithProperties, fieldValue);
+                            }
                         }
                     }
                 }