Add query support for the static methods of System.Decimal

src/NHibernate.Test/NHSpecificTest/GH0831/Entity.cs

@@ -0,0 +1,27 @@
+using System;
+
+namespace NHibernate.Test.NHSpecificTest.GH0831
+{
+	class Entity
+	{
+		public virtual Guid Id { get; set; }
+		public virtual decimal EntityValue { get; set; }
+
+		public override int GetHashCode()
+		{
+			return Id.GetHashCode();
+		}
+
+		public override bool Equals(object obj)
+		{
+			var that = obj as Entity;
+
+			return (that != null) && Id.Equals(that.Id);
+		}
+
+		public override string ToString()
+		{
+			return EntityValue.ToString();
+		}
+	}
+}

src/NHibernate.Test/NHSpecificTest/GH0831/FixtureByCode.cs

@@ -0,0 +1,201 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+
+using NHibernate.Cfg.MappingSchema;
+using NHibernate.Mapping.ByCode;
+
+using NUnit.Framework;
+
+namespace NHibernate.Test.NHSpecificTest.GH0831
+{
+	public class ByCodeFixture : TestCaseMappingByCode
+	{
+		private readonly IList<Entity> entities = new List<Entity>
+		{
+			new Entity { EntityValue = 0.5m },
+			new Entity { EntityValue = 1.0m },
+			new Entity { EntityValue = 1.5m },
+			new Entity { EntityValue = 2.0m },
+			new Entity { EntityValue = 2.5m },
+			new Entity { EntityValue = 3.0m }
+		};
+
+		protected override HbmMapping GetMappings()
+		{
+			var mapper = new ModelMapper();
+			mapper.Class<Entity>(rc =>
+			{
+				rc.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
+				rc.Property(x => x.EntityValue);
+			});
+
+			return mapper.CompileMappingForAllExplicitlyAddedEntities();
+		}
+
+		protected override void OnSetUp()
+		{
+			using (ISession session = OpenSession())
+			using (ITransaction transaction = session.BeginTransaction())
+			{
+				foreach (Entity entity in entities)
+				{
+					session.Save(entity);
+				}
+
+				session.Flush();
+				transaction.Commit();
+			}
+		}
+
+		protected override void OnTearDown()
+		{
+			using (ISession session = OpenSession())
+			using (ITransaction transaction = session.BeginTransaction())
+			{
+				session.Delete("from System.Object");
+
+				session.Flush();
+				transaction.Commit();
+			}
+		}
+
+		[Test]
+		public void CanHandleAdd()
+		{
+			CanFilter(e => decimal.Add(e.EntityValue, 2) > 3.0m);
+			CanFilter(e => decimal.Add(2, e.EntityValue) > 3.0m);
+
+			CanSelect(e => decimal.Add(e.EntityValue, 2));
+			CanSelect(e => decimal.Add(2, e.EntityValue));
+		}
+
+		[Test]
+		public void CanHandleCeiling()
+		{
+			AssumeFunctionSupported("ceiling");
+
+			CanFilter(e => decimal.Ceiling(e.EntityValue) > 1.0m);
+			CanSelect(e => decimal.Ceiling(e.EntityValue));
+		}
+
+		[Test]
+		public void CanHandleCompare()
+		{
+			AssumeFunctionSupported("sign");
+
+			CanFilter(e => decimal.Compare(e.EntityValue, 1.5m) < 1);
+			CanFilter(e => decimal.Compare(1.0m, e.EntityValue) < 1);
+
+			CanSelect(e => decimal.Compare(e.EntityValue, 1.5m));
+			CanSelect(e => decimal.Compare(1.0m, e.EntityValue));
+		}
+
+		[Test]
+		public void CanHandleDivide()
+		{
+			CanFilter(e => decimal.Divide(e.EntityValue, 1.25m) < 1);
+			CanFilter(e => decimal.Divide(1.25m, e.EntityValue) < 1);
+
+			CanSelect(e => decimal.Divide(e.EntityValue, 1.25m));
+			CanSelect(e => decimal.Divide(1.25m, e.EntityValue));
+		}
+
+		[Test]
+		public void CanHandleEquals()
+		{
+			CanFilter(e => decimal.Equals(e.EntityValue, 1.0m));
+			CanFilter(e => decimal.Equals(1.0m, e.EntityValue));
+		}
+
+		[Test]
+		public void CanHandleFloor()
+		{
+			AssumeFunctionSupported("floor");
+
+			CanFilter(e => decimal.Floor(e.EntityValue) > 1.0m);
+			CanSelect(e => decimal.Floor(e.EntityValue));
+		}
+
+		[Test]
+		public void CanHandleMultiply()
+		{
+			CanFilter(e => decimal.Multiply(e.EntityValue, 10m) > 10m);
+			CanFilter(e => decimal.Multiply(10m, e.EntityValue) > 10m);
+
+			CanSelect(e => decimal.Multiply(e.EntityValue, 10m));
+			CanSelect(e => decimal.Multiply(10m, e.EntityValue));
+		}
+
+		[Test]
+		public void CanHandleNegate()
+		{
+			CanFilter(e => decimal.Negate(e.EntityValue) > -1.0m);
+			CanSelect(e => decimal.Negate(e.EntityValue));
+		}
+
+		[Test]
+		public void CanHandleRemainder()
+		{
+			CanFilter(e => decimal.Remainder(e.EntityValue, 2) == 0);
+			CanFilter(e => decimal.Remainder(2, e.EntityValue) < 1);
+
+			CanSelect(e => decimal.Remainder(e.EntityValue, 2));
+			CanSelect(e => decimal.Remainder(2, e.EntityValue));
+		}
+
+		[Test]
+		public void CanHandleRound()
+		{
+			AssumeFunctionSupported("round");
+
+			CanFilter(e => decimal.Round(e.EntityValue) >= 2.0m);
+			CanFilter(e => decimal.Round(e.EntityValue, 1) >= 1.5m);
+
+			// SQL round() always rounds up. 
+			CanSelect(e => decimal.Round(e.EntityValue), entities.Select(e => decimal.Round(e.EntityValue, MidpointRounding.AwayFromZero)));
+			CanSelect(e => decimal.Round(e.EntityValue, 1), entities.Select(e => decimal.Round(e.EntityValue, 1, MidpointRounding.AwayFromZero)));
+		}
+
+		[Test]
+		public void CanHandleSubtract()
+		{
+			CanFilter(e => decimal.Subtract(e.EntityValue, 1m) > 1m);
+			CanFilter(e => decimal.Subtract(2m, e.EntityValue) > 1m);
+
+			CanSelect(e => decimal.Subtract(e.EntityValue, 1m));
+			CanSelect(e => decimal.Subtract(2m, e.EntityValue));
+		}
+
+		private void CanFilter(Expression<Func<Entity, bool>> predicate)
+		{
+			using (ISession session = OpenSession())
+			using (session.BeginTransaction())
+			{
+				IEnumerable<Entity> inMemory = entities.Where(predicate.Compile()).ToList();
+				IEnumerable<Entity> inSession = session.Query<Entity>().Where(predicate).ToList();
+
+				CollectionAssert.AreEquivalent(inMemory, inSession);
+			}
+		}
+
+		private void CanSelect(Expression<Func<Entity, decimal>> predicate)
+		{
+			IEnumerable<decimal> inMemory = entities.Select(predicate.Compile()).ToList();
+
+			CanSelect(predicate, inMemory);
+		}
+
+		private void CanSelect(Expression<Func<Entity, decimal>> predicate, IEnumerable<decimal> expected)
+		{
+			using (ISession session = OpenSession())
+			using (session.BeginTransaction())
+			{
+				IEnumerable<decimal> inSession = session.Query<Entity>().Select(predicate).ToList();
+
+				Assert.That(inSession.OrderBy(x => x), Is.EqualTo(expected.OrderBy(x => x)).Within(0.001M));
+			}
+		}
+	}
+}

src/NHibernate/Linq/Functions/DecimalGenerator.cs

@@ -0,0 +1,71 @@
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+
+using NHibernate.Hql.Ast;
+using NHibernate.Linq.Visitors;
+using NHibernate.Util;
+
+namespace NHibernate.Linq.Functions
+{
+	public class DecimalGenerator : BaseHqlGeneratorForMethod
+	{
+		public DecimalGenerator()
+		{
+			SupportedMethods = new[]
+			{
+				ReflectHelper.GetMethodDefinition(() => decimal.Add(default(decimal), default(decimal))),
+				ReflectHelper.GetMethodDefinition(() => decimal.Ceiling(default(decimal))),
+				ReflectHelper.GetMethodDefinition(() => decimal.Compare(default(decimal), default(decimal))),
+				ReflectHelper.GetMethodDefinition(() => decimal.Divide(default(decimal), default(decimal))),
+				ReflectHelper.GetMethodDefinition(() => decimal.Equals(default(decimal), default(decimal))),
+				ReflectHelper.GetMethodDefinition(() => decimal.Floor(default(decimal))),
+				ReflectHelper.GetMethodDefinition(() => decimal.Multiply(default(decimal), default(decimal))),
+				ReflectHelper.GetMethodDefinition(() => decimal.Negate(default(decimal))),
+				ReflectHelper.GetMethodDefinition(() => decimal.Remainder(default(decimal), default(decimal))),
+				ReflectHelper.GetMethodDefinition(() => decimal.Round(default(decimal))),
+				ReflectHelper.GetMethodDefinition(() => decimal.Round(default(decimal), default(int))),
+				ReflectHelper.GetMethodDefinition(() => decimal.Subtract(default(decimal), default(decimal)))
+			};
+		}
+
+		public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor)
+		{
+			string function = method.Name.ToLowerInvariant();
+
+			HqlExpression[] expressions = arguments.Select(x => visitor.Visit(x).AsExpression()).ToArray();
+
+			switch (function)
+			{
+				case "add":
+					return treeBuilder.Add(expressions[0], expressions[1]);
+				case "subtract":
+					return treeBuilder.Subtract(expressions[0], expressions[1]);
+				case "divide":
+					return treeBuilder.Divide(expressions[0], expressions[1]);
+				case "equals":
+					return treeBuilder.Equality(expressions[0], expressions[1]);
+				case "negate":
+					return treeBuilder.Negate(expressions[0]);
+				case "compare":
+					return treeBuilder.MethodCall("sign", treeBuilder.Subtract(expressions[0], expressions[1]));
+				case "multiply":
+					return treeBuilder.Multiply(expressions[0], expressions[1]);
+				case "remainder":
+					HqlMethodCall mod = treeBuilder.MethodCall("mod", expressions[0], expressions[1]);
+					return treeBuilder.Cast(mod, typeof(decimal));
+				case "round":
+					HqlExpression numberOfDecimals = (arguments.Count == 2) ? expressions[1] : treeBuilder.Constant(0);
+					return treeBuilder.MethodCall("round", expressions[0], numberOfDecimals);
+			}
+
+			if (arguments.Count == 2)
+			{
+				return treeBuilder.MethodCall(function, expressions[0], expressions[1]);
+			}
+
+			return treeBuilder.MethodCall(function, expressions[0]);
+		}
+	}
+}

src/NHibernate/Linq/Functions/DefaultLinqToHqlGeneratorsRegistry.cs

@@ -51,6 +51,8 @@ public DefaultLinqToHqlGeneratorsRegistry()
 			this.Merge(new CollectionContainsGenerator());
 
 			this.Merge(new DateTimePropertiesHqlGenerator());
+
+			this.Merge(new DecimalGenerator());
 		}
 
 		protected bool GetRuntimeMethodGenerator(MethodInfo method, out IHqlGeneratorForMethod methodGenerator)
@@ -100,4 +102,4 @@ public void RegisterGenerator(IRuntimeMethodHqlGenerator generator)
 			runtimeMethodHqlGenerators.Add(generator);
 		}
 	}
-}
+}