Cast operation fails when an enum is mapped as an AnsiString

src/NHibernate.Test/Linq/EnumTests.cs

@@ -1,97 +1,209 @@
-using System.Linq;
-using NHibernate.DomainModel.Northwind.Entities;
+using System;
+using System.Linq;
+using NHibernate.Cfg.MappingSchema;
+using NHibernate.Mapping.ByCode;
+using NHibernate.SqlTypes;
+using NHibernate.Type;
 using NUnit.Framework;
 
 namespace NHibernate.Test.Linq
 {
-	[TestFixture]
-	public class EnumTests : LinqTestCase
+	[TestFixture(typeof(EnumType<TestEnum>))]
+	[TestFixture(typeof(EnumStringType<TestEnum>))]
+	[TestFixture(typeof(EnumAnsiStringType<TestEnum>))]
+	public class EnumTests : TestCaseMappingByCode
 	{
-		[Test]
-		public void CanQueryOnEnumStoredAsInt32_High_1()
+		private IType _enumType;
+
+
+		public EnumTests(System.Type enumType)
 		{
-			CanQueryOnEnumStoredAsInt32(EnumStoredAsInt32.High, 1);
+			_enumType = (IType) Activator.CreateInstance(enumType);
 		}
 
-		[Test]
-		public void CanQueryOnEnumStoredAsInt32_Unspecified_2()
+		protected override HbmMapping GetMappings()
+		{
+			var mapper = new ModelMapper();
+			mapper.Class<EnumEntity>(
+				rc =>
+				{
+					rc.Table("EnumEntity");
+					rc.Id(x => x.Id, m => m.Generator(Generators.Identity));
+					rc.Property(x => x.Name);
+					rc.Property(x => x.Enum, m => m.Type(_enumType));
+					rc.Property(x => x.NullableEnum, m => m.Type(_enumType));
+					rc.ManyToOne(x => x.Other, m => m.Cascade(Mapping.ByCode.Cascade.All));
+				});
+
+
+			return mapper.CompileMappingForAllExplicitlyAddedEntities();
+		}
+
+		protected override void OnSetUp()
 		{
-			CanQueryOnEnumStoredAsInt32(EnumStoredAsInt32.Unspecified, 2);
+			base.OnSetUp();
+			using (var session = OpenSession())
+			using (var trans = session.BeginTransaction())
+			{
+				session.Save(new EnumEntity { Enum = TestEnum.Unspecified });
+				session.Save(new EnumEntity { Enum = TestEnum.Small });
+				session.Save(new EnumEntity { Enum = TestEnum.Small });
+				session.Save(new EnumEntity { Enum = TestEnum.Medium });
+				session.Save(new EnumEntity { Enum = TestEnum.Medium });
+				session.Save(new EnumEntity { Enum = TestEnum.Medium });
+				session.Save(new EnumEntity { Enum = TestEnum.Large });
+				session.Save(new EnumEntity { Enum = TestEnum.Large });
+				session.Save(new EnumEntity { Enum = TestEnum.Large });
+				session.Save(new EnumEntity { Enum = TestEnum.Large });
+				trans.Commit();
+			}
 		}
 
-		public void CanQueryOnEnumStoredAsInt32(EnumStoredAsInt32 type, int expectedCount)
+		protected override void OnTearDown()
 		{
-			var query = (from user in db.Users
-						 where user.Enum2 == type
-						 select user).ToList();
+			using (var session = OpenSession())
+			using (var transaction = session.BeginTransaction())
+			{
+				session.Delete("from System.Object");
 
-			Assert.AreEqual(expectedCount, query.Count);
+				session.Flush();
+				transaction.Commit();
+			}
 		}
 
 		[Test]
-		public void CanQueryOnEnumStoredAsString_Meduim_2()
+		public void CanQueryOnEnum_Large_4()
 		{
-			CanQueryOnEnumStoredAsString(EnumStoredAsString.Medium, 2);
+			CanQueryOnEnum(TestEnum.Large, 4);
 		}
 
 		[Test]
-		public void CanQueryOnEnumStoredAsString_Small_1()
+		public void CanQueryOnEnum_Medium_3()
 		{
-			CanQueryOnEnumStoredAsString(EnumStoredAsString.Small, 1);
+			CanQueryOnEnum(TestEnum.Medium, 3);
 		}
 
-		public void CanQueryOnEnumStoredAsString(EnumStoredAsString type, int expectedCount)
+		[Test]
+		public void CanQueryOnEnum_Small_2()
 		{
-			var query = (from user in db.Users
-						 where user.Enum1 == type
-						 select user).ToList();
+			CanQueryOnEnum(TestEnum.Small, 2);
+		}
 
-			Assert.AreEqual(expectedCount, query.Count);
+		[Test]
+		public void CanQueryOnEnum_Unspecified_1()
+		{
+			CanQueryOnEnum(TestEnum.Unspecified, 1);
+		}
+
+		private void CanQueryOnEnum(TestEnum type, int expectedCount)
+		{
+			using (var session = OpenSession())
+			using (var trans = session.BeginTransaction())
+			{
+				var query = session.Query<EnumEntity>().Where(x => x.Enum == type).ToList();
+
+				Assert.AreEqual(expectedCount, query.Count);
+			}
 		}
 
 		[Test]
-		public void CanQueryWithContainsOnEnumStoredAsString_Small_1()
+		public void CanQueryWithContainsOnTestEnum_Small_1()
 		{
-			var values = new[] { EnumStoredAsString.Small, EnumStoredAsString.Medium };
-			var query = db.Users.Where(x => values.Contains(x.Enum1)).ToList();
-			Assert.AreEqual(3, query.Count);
+			var values = new[] { TestEnum.Small, TestEnum.Medium };
+			using (var session = OpenSession())
+			using (var trans = session.BeginTransaction())
+			{
+				var query = session.Query<EnumEntity>().Where(x => values.Contains(x.Enum)).ToList();
+
+				Assert.AreEqual(5, query.Count);
+			}
 		}
 
 		[Test]
 		public void ConditionalNavigationProperty()
 		{
-			EnumStoredAsString? type = null;
-			db.Users.Where(o => o.Enum1 == EnumStoredAsString.Large).ToList();
-			db.Users.Where(o => EnumStoredAsString.Large != o.Enum1).ToList();
-			db.Users.Where(o => (o.NullableEnum1 ?? EnumStoredAsString.Large) == EnumStoredAsString.Medium).ToList();
-			db.Users.Where(o => ((o.NullableEnum1 ?? type) ?? o.Enum1) == EnumStoredAsString.Medium).ToList();
-
-			db.Users.Where(o => (o.NullableEnum1.HasValue ? o.Enum1 : EnumStoredAsString.Unspecified) == EnumStoredAsString.Medium).ToList();
-			db.Users.Where(o => (o.Enum1 != EnumStoredAsString.Large
-				                    ? (o.NullableEnum1.HasValue ? o.Enum1 : EnumStoredAsString.Unspecified)
-				                    : EnumStoredAsString.Small) == EnumStoredAsString.Medium).ToList();
-
-			db.Users.Where(o => (o.Enum1 == EnumStoredAsString.Large ? o.Role : o.Role).Name == "test").ToList();
+			TestEnum? type = null;
+			using (var session = OpenSession())
+			using (var trans = session.BeginTransaction())
+			{
+				var entities = session.Query<EnumEntity>();
+				entities.Where(o => o.Enum == TestEnum.Large).ToList();
+				entities.Where(o => TestEnum.Large != o.Enum).ToList();
+				entities.Where(o => (o.NullableEnum ?? TestEnum.Large) == TestEnum.Medium).ToList();
+				entities.Where(o => ((o.NullableEnum ?? type) ?? o.Enum) == TestEnum.Medium).ToList();
+
+				entities.Where(o => (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified) == TestEnum.Medium).ToList();
+				entities.Where(o => (o.Enum != TestEnum.Large
+										? (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified)
+										: TestEnum.Small) == TestEnum.Medium).ToList();
+
+				entities.Where(o => (o.Enum == TestEnum.Large ? o.Other : o.Other).Name == "test").ToList();
+			}
 		}
 
 		[Test]
-		public void CanQueryComplexExpressionOnEnumStoredAsString()
+		public void CanQueryComplexExpressionOnTestEnum()
+		{
+			var type = TestEnum.Unspecified;
+			using (var session = OpenSession())
+			using (var trans = session.BeginTransaction())
+			{
+				var entities = session.Query<EnumEntity>();
+
+				var query = (from user in entities
+							 where (user.NullableEnum == TestEnum.Large
+									   ? TestEnum.Medium
+									   : user.NullableEnum ?? user.Enum
+								   ) == type
+							 select new
+							 {
+								 user,
+								 simple = user.Enum,
+								 condition = user.Enum == TestEnum.Large ? TestEnum.Medium : user.Enum,
+								 coalesce = user.NullableEnum ?? TestEnum.Medium
+							 }).ToList();
+
+				Assert.That(query.Count, Is.EqualTo(1));
+			}
+		}
+
+		public class EnumEntity
+		{
+			public virtual int Id { get; set; }
+			public virtual string Name { get; set; }
+
+			public virtual TestEnum Enum { get; set; }
+			public virtual TestEnum? NullableEnum { get; set; }
+
+			public virtual EnumEntity Other { get; set; }
+		}
+
+		public enum TestEnum
 		{
-			var type = EnumStoredAsString.Unspecified;
-			var query = (from user in db.Users
-			             where (user.NullableEnum1 == EnumStoredAsString.Large
-				                   ? EnumStoredAsString.Medium
-				                   : user.NullableEnum1 ?? user.Enum1
-			                   ) == type
-			             select new
-			             {
-				             user,
-				             simple = user.Enum1,
-				             condition = user.Enum1 == EnumStoredAsString.Large ? EnumStoredAsString.Medium : user.Enum1,
-				             coalesce = user.NullableEnum1 ?? EnumStoredAsString.Medium
-			             }).ToList();
-
-			Assert.That(query.Count, Is.EqualTo(0));
+			Unspecified,
+			Small,
+			Medium,
+			Large
+		}
+
+		[Serializable]
+		public class EnumAnsiStringType<T> : EnumStringType
+		{
+			private readonly string typeName;
+
+			public EnumAnsiStringType()
+				: base(typeof(T))
+			{
+				System.Type type = GetType();
+				typeName = type.FullName + ", " + type.Assembly.GetName().Name;
+			}
+
+			public override string Name
+			{
+				get { return typeName; }
+			}
+
+			public override SqlType SqlType => SqlTypeFactory.GetAnsiString(255);
 		}
 	}
 }

src/NHibernate/Linq/Visitors/HqlGeneratorExpressionVisitor.cs

@@ -634,7 +634,7 @@ private bool IsCastRequired(IType type, IType toType, out bool existType)
 				return false;
 			}
 
-			if (type.ReturnedClass.IsEnum && sqlTypes[0].DbType == DbType.String)
+			if (type.ReturnedClass.IsEnum && sqlTypes[0].DbType.IsStringType())
 			{
 				existType = false;
 				return false; // Never cast an enum that is mapped as string, the type will provide a string for the parameter value

src/NHibernate/Util/DbTypeExtensions.cs

@@ -0,0 +1,14 @@
+using System.Data;
+
+namespace NHibernate.Util
+{
+	internal static class DbTypeExtensions
+	{
+		/// <summary>
+		/// Checks whether the type is a <see cref="DbType.String"/>, <see cref="DbType.AnsiString"/>, <see cref="DbType.StringFixedLength"/> or <see cref="DbType.AnsiStringFixedLength"/>
+		/// </summary>
+		/// <param name="dbType"></param>
+		/// <returns></returns>
+		public static bool IsStringType(this DbType dbType) => dbType == DbType.String || dbType == DbType.AnsiString || dbType == DbType.StringFixedLength || dbType == DbType.AnsiStringFixedLength;
+	}
+}