Support basic arithmetic operations (+, -, *, /) in QueryOver

Author: bahusoid

src/NHibernate.Test/Async/Criteria/Lambda/IntegrationFixture.cs

@@ -510,5 +510,31 @@ public async Task StatelessSessionAsync()
 				Assert.That(statelessPerson2.Id, Is.EqualTo(personId));
 			}
 		}
+
+		[Test]
+		public async Task QueryOverArithmeticAsync()
+		{
+			using (ISession s = OpenSession())
+			using (ITransaction t = s.BeginTransaction())
+			{
+				await (s.SaveAsync(new Person() {Name = "test person 1", Age = 20}));
+				await (s.SaveAsync(new Person() {Name = "test person 2", Age = 50}));
+				await (t.CommitAsync());
+			}
+
+			using (var s = OpenSession())
+			{
+				var persons1 = await (s.QueryOver<Person>().Where(p => (p.Age * 2) / 2 + 20 - 20 == 20).ListAsync());
+				var persons2 = await (s.QueryOver<Person>().Where(p => (-(-p.Age)) > 20).ListAsync());
+				var persons3 = await (s.QueryOver<Person>().WhereRestrictionOn(p => (p.Age * 2) / 2 + 20 - 20).IsBetween(19).And(21).ListAsync());
+				var persons4 = await (s.QueryOver<Person>().WhereRestrictionOn(p => -(-p.Age)).IsBetween(19).And(21).ListAsync());
+				var persons5 = await (s.QueryOver<Person>().WhereRestrictionOn(p => (p.Age * 2) / 2 + 20 - 20).IsBetween(19).And(51).ListAsync());
+				Assert.That(persons1.Count, Is.EqualTo(1));
+				Assert.That(persons2.Count, Is.EqualTo(1));
+				Assert.That(persons3.Count, Is.EqualTo(1));
+				Assert.That(persons4.Count, Is.EqualTo(1));
+				Assert.That(persons5.Count, Is.EqualTo(2));
+			}
+		}
 	}
 }

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

@@ -498,5 +498,31 @@ public void StatelessSession()
 				Assert.That(statelessPerson2.Id, Is.EqualTo(personId));
 			}
 		}
+
+		[Test]
+		public void QueryOverArithmetic()
+		{
+			using (ISession s = OpenSession())
+			using (ITransaction t = s.BeginTransaction())
+			{
+				s.Save(new Person() {Name = "test person 1", Age = 20});
+				s.Save(new Person() {Name = "test person 2", Age = 50});
+				t.Commit();
+			}
+
+			using (var s = OpenSession())
+			{
+				var persons1 = s.QueryOver<Person>().Where(p => (p.Age * 2) / 2 + 20 - 20 == 20).List();
+				var persons2 = s.QueryOver<Person>().Where(p => (-(-p.Age)) > 20).List();
+				var persons3 = s.QueryOver<Person>().WhereRestrictionOn(p => (p.Age * 2) / 2 + 20 - 20).IsBetween(19).And(21).List();
+				var persons4 = s.QueryOver<Person>().WhereRestrictionOn(p => -(-p.Age)).IsBetween(19).And(21).List();
+				var persons5 = s.QueryOver<Person>().WhereRestrictionOn(p => (p.Age * 2) / 2 + 20 - 20).IsBetween(19).And(51).List();
+				Assert.That(persons1.Count, Is.EqualTo(1));
+				Assert.That(persons2.Count, Is.EqualTo(1));
+				Assert.That(persons3.Count, Is.EqualTo(1));
+				Assert.That(persons4.Count, Is.EqualTo(1));
+				Assert.That(persons5.Count, Is.EqualTo(2));
+			}
+		}
 	}
 }

src/NHibernate/Impl/ExpressionProcessor.cs

@@ -6,6 +6,8 @@
 using System.Runtime.CompilerServices;
 using System.Text.RegularExpressions;
 using NHibernate.Criterion;
+using NHibernate.Dialect.Function;
+using NHibernate.Type;
 using NHibernate.Util;
 using Expression = System.Linq.Expressions.Expression;
 
@@ -104,6 +106,8 @@ public string AsProperty()
 		private static readonly Dictionary<LambdaSubqueryType, IDictionary<ExpressionType, Func<string, DetachedCriteria, AbstractCriterion>>> _subqueryExpressionCreatorTypes;
 		private static readonly Dictionary<string, Func<MethodCallExpression, ICriterion>> _customMethodCallProcessors;
 		private static readonly Dictionary<string, Func<Expression, IProjection>> _customProjectionProcessors;
+		private static readonly Dictionary<ExpressionType, ISQLFunction> _binaryArithmethicTemplates = new Dictionary<ExpressionType, ISQLFunction>();
+		private static readonly ISQLFunction _unaryNegateTemplate;
 
 		static ExpressionProcessor()
 		{
@@ -198,6 +202,17 @@ static ExpressionProcessor()
 			RegisterCustomProjection(() => Math.Round(default(double), default(int)), ProjectionsExtensions.ProcessRound);
 			RegisterCustomProjection(() => Math.Round(default(decimal), default(int)), ProjectionsExtensions.ProcessRound);
 			RegisterCustomProjection(() => ProjectionsExtensions.AsEntity(default(object)), ProjectionsExtensions.ProcessAsEntity);
+
+			RegisterBinaryArithmeticExpression(ExpressionType.Add, "+");
+			RegisterBinaryArithmeticExpression(ExpressionType.Subtract, "-");
+			RegisterBinaryArithmeticExpression(ExpressionType.Multiply, "*");
+			RegisterBinaryArithmeticExpression(ExpressionType.Divide, "/");
+			_unaryNegateTemplate = new VarArgsSQLFunction("(-", string.Empty, ")");
+		}
+
+		private static void RegisterBinaryArithmeticExpression(ExpressionType type, string sqlOperand)
+		{
+			_binaryArithmethicTemplates[type] = new VarArgsSQLFunction("(", sqlOperand, ")");
 		}
 
 		private static ICriterion Eq(ProjectionInfo property, object value)
@@ -248,15 +263,12 @@ public static object FindValue(Expression expression)
 		public static ProjectionInfo FindMemberProjection(Expression expression)
 		{
 			if (!IsMemberExpression(expression))
-				return ProjectionInfo.ForProjection(Projections.Constant(FindValue(expression)));
+				return AsArithmeticExpression(expression) ?? ProjectionInfo.ForProjection(Projections.Constant(FindValue(expression)));
 
-			var unaryExpression = expression as UnaryExpression;
-			if (unaryExpression != null)
+			var unwrapExpression = UnwrapConvertExpression(expression);
+			if (unwrapExpression != null)
 			{
-				if (!IsConversion(unaryExpression.NodeType))
-					throw new ArgumentException("Cannot interpret member from " + expression, nameof(expression));
-
-				return FindMemberProjection(unaryExpression.Operand);
+				return FindMemberProjection(unwrapExpression);
 			}
 
 			var methodCallExpression = expression as MethodCallExpression;
@@ -283,6 +295,55 @@ public static ProjectionInfo FindMemberProjection(Expression expression)
 			return ProjectionInfo.ForProperty(FindMemberExpression(expression));
 		}
 
+		private static Expression UnwrapConvertExpression(Expression expression)
+		{
+			if (expression is UnaryExpression unaryExpression)
+			{
+				if (!IsConversion(unaryExpression.NodeType))
+				{
+					if (IsSupportedUnaryExpression(unaryExpression))
+						return null;
+
+					throw new ArgumentException("Cannot interpret member from " + expression, nameof(expression));
+				}
+				return unaryExpression.Operand;
+			}
+
+			return null;
+		}
+
+		private static bool IsSupportedUnaryExpression(UnaryExpression expression)
+		{
+			return expression.NodeType == ExpressionType.Negate;
+		}
+
+		private static ProjectionInfo AsArithmeticExpression(Expression expression)
+		{
+			if (!(expression is BinaryExpression be))
+			{
+				if (expression is UnaryExpression unary && unary.NodeType == ExpressionType.Negate)
+				{
+					return ProjectionInfo.ForProjection(
+						new SqlFunctionProjection(_unaryNegateTemplate, TypeFactory.HeuristicType(unary.Type), FindMemberProjection(unary.Operand).AsProjection()));
+				}
+
+				var unwrapExpression = UnwrapConvertExpression(expression);
+				return unwrapExpression != null ? AsArithmeticExpression(unwrapExpression) : null;
+			}
+
+			if (!_binaryArithmethicTemplates.TryGetValue(be.NodeType, out var template))
+			{
+				return null;
+			}
+
+			return ProjectionInfo.ForProjection(
+				new SqlFunctionProjection(
+					template,
+					TypeFactory.HeuristicType(be.Type),
+					FindMemberProjection(be.Left).AsProjection(),
+					FindMemberProjection(be.Right).AsProjection()));
+		}
+
 		//http://stackoverflow.com/a/2509524/259946
 		private static readonly Regex GeneratedMemberNameRegex = new Regex(@"^(CS\$)?<\w*>[1-9a-s]__[a-zA-Z]+[0-9]*$", RegexOptions.Compiled | RegexOptions.Singleline);
 
@@ -410,13 +471,10 @@ private static System.Type FindMemberType(Expression expression)
 				return memberExpression.Type;
 			}
 
-			var unaryExpression = expression as UnaryExpression;
-			if (unaryExpression != null)
+			var unwrapExpression = UnwrapConvertExpression(expression);
+			if (unwrapExpression != null)
 			{
-				if (!IsConversion(unaryExpression.NodeType))
-					throw new ArgumentException("Cannot interpret member from " + expression, nameof(expression));
-
-				return FindMemberType(unaryExpression.Operand);
+				return FindMemberType(unwrapExpression);
 			}
 
 			var methodCallExpression = expression as MethodCallExpression;
@@ -425,6 +483,9 @@ private static System.Type FindMemberType(Expression expression)
 				return methodCallExpression.Method.ReturnType;
 			}
 
+			if (expression is BinaryExpression || expression is UnaryExpression)
+				return expression.Type;
+
 			throw new ArgumentException("Could not determine member type from " + expression, nameof(expression));
 		}
 
@@ -446,13 +507,10 @@ private static bool IsMemberExpression(Expression expression)
 				return EvaluatesToNull(memberExpression.Expression);
 			}
 
-			var unaryExpression = expression as UnaryExpression;
-			if (unaryExpression != null)
+			var unwrapExpression = UnwrapConvertExpression(expression);
+			if (unwrapExpression != null)
 			{
-				if (!IsConversion(unaryExpression.NodeType))
-					throw new ArgumentException("Cannot interpret member from " + expression, nameof(expression));
-
-				return IsMemberExpression(unaryExpression.Operand);
+				return IsMemberExpression(unwrapExpression);
 			}
 
 			var methodCallExpression = expression as MethodCallExpression;