NH-3787 - Fix decimal truncation in some Linq queries

Author: fredericDelaporte

src/NHibernate.Test/Async/NHSpecificTest/NH3787/TestFixture.cs

@@ -0,0 +1,131 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by AsyncGenerator.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+
+using System.Linq;
+using NHibernate.Criterion;
+using NHibernate.Transform;
+using NUnit.Framework;
+using NHibernate.Linq;
+
+namespace NHibernate.Test.NHSpecificTest.NH3787
+{
+	using System.Threading.Tasks;
+	[TestFixture]
+	public class TestFixtureAsync : BugTestCase
+	{
+		private const decimal _testRate = 12345.123456789M;
+
+		protected override void OnSetUp()
+		{
+			base.OnSetUp();
+
+			using (var s = OpenSession())
+			using (var t = s.BeginTransaction())
+			{
+				var testEntity = new TestEntity
+				{
+					UsePreviousRate = true,
+					PreviousRate = _testRate,
+					Rate = 54321.123456789M
+				};
+				s.Save(testEntity);
+				t.Commit();
+			}
+		}
+
+		protected override void OnTearDown()
+		{
+			using (var s = OpenSession())
+			using (var t = s.BeginTransaction())
+			{
+				s.CreateQuery("delete from TestEntity").ExecuteUpdate();
+				t.Commit();
+			}
+		}
+
+		[Test]
+		public async Task TestLinqQueryAsync()
+		{
+			using (var s = OpenSession())
+			using (var t = s.BeginTransaction())
+			{
+				var queryResult = await (s
+					.Query<TestEntity>()
+					.Where(e => e.PreviousRate == _testRate)
+					.ToListAsync());
+
+				Assert.That(queryResult.Count, Is.EqualTo(1));
+				Assert.That(queryResult[0].PreviousRate, Is.EqualTo(_testRate));
+				await (t.CommitAsync());
+			}
+		}
+
+		[Test]
+		public async Task TestLinqProjectionAsync()
+		{
+			using (var s = OpenSession())
+			using (var t = s.BeginTransaction())
+			{
+				var queryResult = await ((from test in s.Query<TestEntity>()
+				                   select new RateDto { Rate = test.UsePreviousRate ? test.PreviousRate : test.Rate }).ToListAsync());
+
+				// Check it has not been truncated to the default 5 positions of NHibernate.
+				Assert.That(queryResult[0].Rate, Is.EqualTo(_testRate));
+				await (t.CommitAsync());
+			}
+		}
+
+		[Test]
+		public async Task TestLinqQueryOnExpressionAsync()
+		{
+			using (var s = OpenSession())
+			using (var t = s.BeginTransaction())
+			{
+				var queryResult = await (s
+					.Query<TestEntity>()
+					.Where(e => (e.UsePreviousRate ? e.PreviousRate : e.Rate) == _testRate)
+					.ToListAsync());
+		
+				Assert.That(queryResult.Count, Is.EqualTo(1));
+				Assert.That(queryResult[0].PreviousRate, Is.EqualTo(_testRate));
+				await (t.CommitAsync());
+			}
+		}
+
+		[Test]
+		public async Task TestQueryOverProjectionAsync()
+		{
+			using (var s = OpenSession())
+			using (var t = s.BeginTransaction())
+			{
+				TestEntity testEntity = null;
+
+				var rateDto = new RateDto();
+				//Generated sql
+				//exec sp_executesql N'SELECT (case when this_.UsePreviousRate = @p0 then this_.PreviousRate else this_.Rate end) as y0_ FROM [TestEntity] this_',N'@p0 bit',@p0=1
+				var query = s
+					.QueryOver(() => testEntity)
+					.Select(
+						Projections.Alias(
+							           Projections.Conditional(
+								           Restrictions.Eq(Projections.Property(() => testEntity.UsePreviousRate), true),
+								           Projections.Property(() => testEntity.PreviousRate),
+								           Projections.Property(() => testEntity.Rate)),
+							           "Rate")
+						           .WithAlias(() => rateDto.Rate));
+
+				var queryResult = await (query.TransformUsing(Transformers.AliasToBean<RateDto>()).ListAsync<RateDto>());
+
+				Assert.That(queryResult[0].Rate, Is.EqualTo(_testRate));
+				await (t.CommitAsync());
+			}
+		}
+	}
+}

src/NHibernate.Test/NHSpecificTest/NH3787/TestFixture.cs

@@ -70,7 +70,7 @@ public void TestLinqProjection()
 			}
 		}
 
-		[Test, Ignore("Not fixed yet.")]
+		[Test]
 		public void TestLinqQueryOnExpression()
 		{
 			using (var s = OpenSession())

src/NHibernate/Dialect/Dialect.cs

@@ -98,6 +98,7 @@ protected Dialect()
 			RegisterFunction("upper", new StandardSQLFunction("upper"));
 			RegisterFunction("lower", new StandardSQLFunction("lower"));
 			RegisterFunction("cast", new CastFunction());
+			RegisterFunction("transparentcast", new TransparentCastFunction());
 			RegisterFunction("extract", new AnsiExtractFunction());
 			RegisterFunction("concat", new VarArgsSQLFunction(NHibernateUtil.String, "(", "||", ")"));
 

src/NHibernate/Dialect/Function/TransparentCastFunction.cs

@@ -0,0 +1,16 @@
+using System;
+
+namespace NHibernate.Dialect.Function
+{
+	/// <summary>
+	/// A HQL only cast for helping HQL knowing the type. Does not generates any actual cast in SQL code.
+	/// </summary>
+	[Serializable]
+	public class TransparentCastFunction : CastFunction
+	{
+		protected override bool CastingIsRequired(string sqlType)
+		{
+			return false;
+		}
+	}
+}

src/NHibernate/Hql/Ast/ANTLR/SessionFactoryHelperExtensions.cs

@@ -77,7 +77,7 @@ public IType FindFunctionReturnType(String functionName, IASTNode first)
 
 			if (first != null)
 			{
-				if (functionName == "cast")
+				if (sqlFunction is CastFunction)
 				{
 					argumentType = TypeFactory.HeuristicType(first.NextSibling.Text);
 				}

src/NHibernate/Hql/Ast/HqlTreeBuilder.cs

@@ -301,6 +301,17 @@ public HqlCast Cast(HqlExpression expression, System.Type type)
 			return new HqlCast(_factory, expression, type);
 		}
 
+		/// <summary>
+		/// Generate a cast node intended solely to hint HQL at the resulting type, without issuing an actual SQL cast.
+		/// </summary>
+		/// <param name="expression">The expression to cast.</param>
+		/// <param name="type">The resulting type.</param>
+		/// <returns>A <see cref="HqlTransparentCast"/> node.</returns>
+		public HqlTransparentCast TransparentCast(HqlExpression expression, System.Type type)
+		{
+			return new HqlTransparentCast(_factory, expression, type);
+		}
+
 		public HqlBitwiseNot BitwiseNot()
 		{
 			return new HqlBitwiseNot(_factory);

src/NHibernate/Hql/Ast/HqlTreeNode.cs

@@ -701,6 +701,19 @@ public HqlCast(IASTFactory factory, HqlExpression expression, System.Type type)
 		}
 	}
 
+	/// <summary>
+	/// Cast node intended solely to hint HQL at the resulting type, without issuing an actual SQL cast.
+	/// </summary>
+	public class HqlTransparentCast : HqlExpression
+	{
+		public HqlTransparentCast(IASTFactory factory, HqlExpression expression, System.Type type)
+			: base(HqlSqlWalker.METHOD_CALL, "method", factory)
+		{
+			AddChild(new HqlIdent(factory, "transparentcast"));
+			AddChild(new HqlExpressionList(factory, expression, new HqlIdent(factory, type)));
+		}
+	}
+
 	public class HqlCoalesce : HqlExpression
 	{
 		public HqlCoalesce(IASTFactory factory, HqlExpression lhs, HqlExpression rhs)

src/NHibernate/Linq/Visitors/HqlGeneratorExpressionVisitor.cs

@@ -8,7 +8,6 @@
 using NHibernate.Param;
 using NHibernate.Util;
 using Remotion.Linq.Clauses.Expressions;
-using Remotion.Linq.Clauses.ResultOperators;
 
 namespace NHibernate.Linq.Visitors
 {
@@ -538,9 +537,12 @@ protected HqlTreeNode VisitConditionalExpression(ConditionalExpression expressio
 
 			HqlExpression @case = _hqlTreeBuilder.Case(new[] {_hqlTreeBuilder.When(test, ifTrue)}, ifFalse);
 
-			return (expression.Type == typeof (bool) || expression.Type == (typeof (bool?)))
-					   ? @case
-					   : _hqlTreeBuilder.Cast(@case, expression.Type);
+			// If both operands are parameters, HQL will not be able to determine the resulting type before
+			// parameters binding. But it has to compute result set columns type before parameters are bound,
+			// so an artificial cast is introduced to hint HQL at the resulting type.
+			return expression.Type == typeof(bool) || expression.Type == typeof(bool?)
+				? @case
+				: _hqlTreeBuilder.TransparentCast(@case, expression.Type);
 		}
 
 		protected HqlTreeNode VisitSubQueryExpression(SubQueryExpression expression)