NH-3647 Support Math.Round in QueryOver() projections.

Author: oskarb

src/NHibernate.Test/Criteria/Lambda/FunctionsIntegrationFixture.cs

@@ -113,14 +113,79 @@ public void SqrtSingleOrDefault()
 			{
 				var sqrtOfAge = s.QueryOver<Person>()
 					.Where(p => p.Name == "p1")
-					.Select(p => p.Age.Sqrt())
+					.Select(p => Math.Round(p.Age.Sqrt(), 2))
 					.SingleOrDefault<object>();
 
 				sqrtOfAge.Should().Be.InstanceOf<double>();
 				string.Format("{0:0.00}", sqrtOfAge).Should().Be((9.49).ToString());
 			}
 		}
 
+
+		[Test]
+		public void RoundDoubleWithOneArgument()
+		{
+			using (var s = OpenSession())
+			using (s.BeginTransaction())
+			{
+				var roundedValue = s.QueryOver<Person>()
+				                    .Where(p => p.Name == "p1")
+				                    .Select(p => Math.Round(p.Age.Sqrt()))
+				                    .SingleOrDefault<object>();
+
+				roundedValue.Should().Be.InstanceOf<double>();
+				Assert.That(roundedValue, Is.EqualTo(9));
+			}
+		}
+
+		[Test]
+		public void RoundDecimalWithOneArgument()
+		{
+			using (var s = OpenSession())
+			using (s.BeginTransaction())
+			{
+				var roundedValue = s.QueryOver<Person>()
+				                    .Where(p => p.Name == "p1")
+				                    .Select(p => Math.Round((decimal) p.Age.Sqrt()))
+				                    .SingleOrDefault<object>();
+
+				roundedValue.Should().Be.InstanceOf<double>();
+				Assert.That(roundedValue, Is.EqualTo(9));
+			}
+		}
+
+		[Test]
+		public void RoundDoubleWithTwoArguments()
+		{
+			using (var s = OpenSession())
+			using (s.BeginTransaction())
+			{
+				var roundedValue = s.QueryOver<Person>()
+									.Where(p => p.Name == "p1")
+									.Select(p => Math.Round(p.Age.Sqrt() , 3))
+									.SingleOrDefault<object>();
+
+				roundedValue.Should().Be.InstanceOf<double>();
+				Assert.That(roundedValue, Is.EqualTo(9.487).Within(0.000001));
+			}
+		}
+
+		[Test]
+		public void RoundDecimalWithTwoArguments()
+		{
+			using (var s = OpenSession())
+			using (s.BeginTransaction())
+			{
+				var roundedValue = s.QueryOver<Person>()
+				                    .Where(p => p.Name == "p1")
+				                    .Select(p => Math.Round((decimal) p.Age.Sqrt(), 3))
+				                    .SingleOrDefault<object>();
+
+				roundedValue.Should().Be.InstanceOf<double>();
+				Assert.That(roundedValue, Is.EqualTo(9.487).Within(0.000001));
+			}
+		}
+
 		[Test]
 		public void FunctionsToLowerToUpper()
 		{

src/NHibernate/Criterion/ProjectionsExtensions.cs

@@ -245,6 +245,20 @@ internal static IProjection ProcessInt64Abs(MethodCallExpression methodCallExpre
 			return Projections.SqlFunction("abs", NHibernateUtil.Int64, property);
 		}
 
+
+		internal static IProjection ProcessRound(MethodCallExpression methodCallExpression)
+		{
+			IProjection innerProjection =
+				ExpressionProcessor.FindMemberProjection(methodCallExpression.Arguments[0]).AsProjection();
+
+			IProjection digitsProjection = Projections.Constant(0);
+			if (methodCallExpression.Arguments.Count > 1)
+				digitsProjection = ExpressionProcessor.FindMemberProjection(methodCallExpression.Arguments[1]).AsProjection();
+
+			return Projections.SqlFunction("round", NHibernateUtil.Double, innerProjection, digitsProjection);
+		}
+
+
 		/// <summary>
 		/// Project SQL function abs()
 		/// Note: throws an exception outside of a QueryOver expression

src/NHibernate/Impl/ExpressionProcessor.cs

@@ -200,6 +200,11 @@ static ExpressionProcessor()
 			RegisterCustomProjection(() => ProjectionsExtensions.Abs(default(int)), ProjectionsExtensions.ProcessIntAbs);
 			RegisterCustomProjection(() => ProjectionsExtensions.Abs(default(double)), ProjectionsExtensions.ProcessDoubleAbs);
 			RegisterCustomProjection(() => ProjectionsExtensions.Abs(default(Int64)), ProjectionsExtensions.ProcessInt64Abs);
+
+			RegisterCustomProjection(() => Math.Round(default(double)), ProjectionsExtensions.ProcessRound);
+			RegisterCustomProjection(() => Math.Round(default(decimal)), ProjectionsExtensions.ProcessRound);
+			RegisterCustomProjection(() => Math.Round(default(double), default(int)), ProjectionsExtensions.ProcessRound);
+			RegisterCustomProjection(() => Math.Round(default(decimal), default(int)), ProjectionsExtensions.ProcessRound);
 		}
 
 		private static ICriterion Eq(ProjectionInfo property, object value)