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,249 @@
+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()
+		{
+			Assert.Multiple(() =>
+			{
+				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");
+
+			Assert.Multiple(() =>
+			{
+				CanFilter(e => decimal.Ceiling(e.EntityValue) > 1.0m);
+				CanSelect(e => decimal.Ceiling(e.EntityValue));
+			});
+		}
+
+		[Test]
+		public void CanHandleCompare()
+		{
+			AssumeFunctionSupported("sign");
+
+			Assert.Multiple(() =>
+			{
+				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()
+		{
+			Assert.Multiple(() =>
+			{
+				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()
+		{
+			Assert.Multiple(() =>
+			{
+				CanFilter(e => decimal.Equals(e.EntityValue, 1.0m));
+				CanFilter(e => decimal.Equals(1.0m, e.EntityValue));
+			});
+		}
+
+		[Test]
+		public void CanHandleFloor()
+		{
+			AssumeFunctionSupported("floor");
+
+			Assert.Multiple(() =>
+			{
+				CanFilter(e => decimal.Floor(e.EntityValue) > 1.0m);
+				CanSelect(e => decimal.Floor(e.EntityValue));
+			});
+		}
+
+		[Test]
+		public void CanHandleMultiply()
+		{
+			Assert.Multiple(() =>
+			{
+				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()
+		{
+			Assert.Multiple(() =>
+			{
+				CanFilter(e => decimal.Negate(e.EntityValue) > -1.0m);
+				CanSelect(e => decimal.Negate(e.EntityValue));
+			});
+		}
+
+		[Test]
+		public void CanHandleRemainder()
+		{
+			Assume.That(TestDialect.SupportsModuloOnDecimal, Is.True);
+
+			Assert.Multiple(() =>
+			{
+				CanFilter(e => decimal.Remainder(e.EntityValue, 2m) == 0);
+				CanFilter(e => decimal.Remainder(2m, e.EntityValue) < 1);
+
+				CanSelect(e => decimal.Remainder(e.EntityValue, 2m));
+				CanSelect(e => decimal.Remainder(2m, e.EntityValue));
+			});
+		}
+
+		[Test]
+		public void CanHandleRound()
+		{
+			AssumeFunctionSupported("round");
+
+			Assert.Multiple(() =>
+			{
+				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()
+		{
+			Assert.Multiple(() =>
+			{
+				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));
+			});
+		}
+
+		[Test]
+		public void CanHandleTruncate()
+		{
+			AssumeFunctionSupported("truncate");
+
+			Assert.Multiple(() =>
+			{
+				CanFilter(e => decimal.Truncate(e.EntityValue) > 1m);
+				CanSelect(e => decimal.Truncate(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 = null;
+				Assert.That(() => inSession = session.Query<Entity>().Select(predicate).ToList(), Throws.Nothing);
+
+				Assert.That(inSession, Is.EquivalentTo(expected).Using((decimal a, decimal b) => Math.Abs(a - b) < 0.0001m));
+			}
+		}
+	}
+}

src/NHibernate.Test/TestDialect.cs

@@ -75,5 +75,10 @@ public bool SupportsSqlType(SqlType sqlType)
 				return false;
 			}
 		}
+
+		/// <summary>
+		/// Supports the modulo operator on decimal types
+		/// </summary>
+		public virtual bool SupportsModuloOnDecimal => true;
 	}
 }

src/NHibernate.Test/TestDialects/FirebirdTestDialect.cs

@@ -8,5 +8,9 @@ public FirebirdTestDialect(Dialect.Dialect dialect) : base(dialect)
 
 		public override bool SupportsComplexExpressionInGroupBy => false;
 		public override bool SupportsNonDataBoundCondition => false;
+		/// <summary>
+		/// Non-integer arguments are rounded before the division takes place. So, “7.5 mod 2.5” gives 2 (8 mod 3), not 0.
+		/// </summary>
+		public override bool SupportsModuloOnDecimal => false;
 	}
 }

src/NHibernate.Test/TestDialects/MsSqlCe40TestDialect.cs

@@ -25,5 +25,10 @@ public MsSqlCe40TestDialect(Dialect.Dialect dialect) : base(dialect)
 		public override bool SupportsDuplicatedColumnAliases => false;
 
 		public override bool SupportsEmptyInserts => false;
+
+		/// <summary>
+		/// Modulo is not supported on real, float, money, and numeric data types. [ Data type = numeric ]
+		/// </summary>
+		public override bool SupportsModuloOnDecimal => false;
 	}
 }

src/NHibernate.Test/TestDialects/SQLiteTestDialect.cs

@@ -44,5 +44,7 @@ public override bool SupportsHavingWithoutGroupBy
 		{
 			get { return false; }
 		}
+
+		public override bool SupportsModuloOnDecimal => false;
 	}
 }

src/NHibernate/Dialect/FirebirdDialect.cs

@@ -464,7 +464,8 @@ private void RegisterMathematicalFunctions()
 			RegisterFunction("rand", new NoArgSQLFunction("rand", NHibernateUtil.Double));
 			RegisterFunction("sign", new StandardSQLFunction("sign", NHibernateUtil.Int32));
 			RegisterFunction("sqtr", new StandardSQLFunction("sqtr", NHibernateUtil.Double));
-			RegisterFunction("truncate", new StandardSQLFunction("truncate"));
+			RegisterFunction("trunc", new StandardSQLFunction("trunc"));
+			RegisterFunction("truncate", new StandardSQLFunction("trunc"));
 			RegisterFunction("floor", new StandardSQLFunction("floor"));
 			RegisterFunction("round", new StandardSQLFunction("round"));
 		}

src/NHibernate/Dialect/MsSql2000Dialect.cs

@@ -287,6 +287,7 @@ protected virtual void RegisterFunctions()
 			RegisterFunction("ceil", new StandardSQLFunction("ceiling"));
 			RegisterFunction("floor", new StandardSQLFunction("floor"));
 			RegisterFunction("round", new RoundEmulatingSingleParameterFunction());
+			RegisterFunction("truncate", new SQLFunctionTemplate(null, "round(?1, ?2, 1)"));
 
 			RegisterFunction("power", new StandardSQLFunction("power", NHibernateUtil.Double));
 

src/NHibernate/Dialect/MsSqlCeDialect.cs

@@ -195,6 +195,7 @@ protected virtual void RegisterFunctions()
 			RegisterFunction("mod", new SQLFunctionTemplate(NHibernateUtil.Int32, "((?1) % (?2))"));
 
 			RegisterFunction("round", new RoundEmulatingSingleParameterFunction());
+			RegisterFunction("truncate", new SQLFunctionTemplate(null, "round(?1, ?2, 1)"));
 
 			RegisterFunction("bit_length", new SQLFunctionTemplate(NHibernateUtil.Int32, "datalength(?1) * 8"));
 			RegisterFunction("extract", new SQLFunctionTemplate(NHibernateUtil.Int32, "datepart(?1, ?3)"));

src/NHibernate/Dialect/MySQLDialect.cs

@@ -261,8 +261,8 @@ protected virtual void RegisterFunctions()
 			RegisterFunction("ceiling", new StandardSQLFunction("ceiling"));
 			RegisterFunction("floor", new StandardSQLFunction("floor"));
 			RegisterFunction("round", new StandardSQLFunction("round"));
-			RegisterFunction("truncate", new StandardSQLFunction("truncate"));
-			
+			RegisterFunction("truncate", new StandardSafeSQLFunction("truncate", 2));
+
 			RegisterFunction("rand", new NoArgSQLFunction("rand", NHibernateUtil.Double));
 
 			RegisterFunction("power", new StandardSQLFunction("power", NHibernateUtil.Double));

src/NHibernate/Dialect/Oracle8iDialect.cs

@@ -229,6 +229,7 @@ protected virtual void RegisterFunctions()
 
 			RegisterFunction("round", new StandardSQLFunction("round"));
 			RegisterFunction("trunc", new StandardSQLFunction("trunc"));
+			RegisterFunction("truncate", new StandardSQLFunction("trunc"));
 			RegisterFunction("ceil", new StandardSQLFunction("ceil"));
 			RegisterFunction("ceiling", new StandardSQLFunction("ceil"));
 			RegisterFunction("floor", new StandardSQLFunction("floor"));

src/NHibernate/Dialect/SybaseSQLAnywhere10Dialect.cs

@@ -343,6 +343,8 @@ protected virtual void RegisterMiscellaneousFunctions()
 			RegisterFunction("transactsql", new StandardSQLFunction("transactsql", NHibernateUtil.String));
 			RegisterFunction("varexists", new StandardSQLFunction("varexists", NHibernateUtil.Int32));
 			RegisterFunction("watcomsql", new StandardSQLFunction("watcomsql", NHibernateUtil.String));
+			RegisterFunction("truncnum", new StandardSafeSQLFunction("truncnum", 2));
+			RegisterFunction("truncate", new StandardSafeSQLFunction("truncnum", 2));
 		}
 
 		#region private static readonly string[] DialectKeywords = { ... }

src/NHibernate/Linq/Functions/CompareGenerator.cs

@@ -32,6 +32,8 @@ internal class CompareGenerator : BaseHqlGeneratorForMethod, IRuntimeMethodHqlGe
 
 				ReflectHelper.GetMethodDefinition<float>(x => x.CompareTo(x)),
 				ReflectHelper.GetMethodDefinition<double>(x => x.CompareTo(x)),
+
+				ReflectHelper.GetMethodDefinition(() => decimal.Compare(default(decimal), default(decimal))),
 				ReflectHelper.GetMethodDefinition<decimal>(x => x.CompareTo(x)),
 
 				ReflectHelper.GetMethodDefinition<DateTime>(x => x.CompareTo(x)),