Support calculations on both sides of boolean expression

Author: bahusoid

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

@@ -529,11 +529,20 @@ public async Task QueryOverArithmeticAsync()
 				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());
+				var persons6 = await (s.QueryOver<Person>().Where(p => (p.Age * 2) / 2 + 20 - 20 == p.Age - p.Age + 20).ListAsync());
+#pragma warning disable CS0472 // The result of the expression is always the same since a value of this type is never equal to 'null'
+				var persons7 = await (s.QueryOver<Person>().Where(p => (p.Age * 2) / 2 + 20 - 20 == null || p.Age * 2 == 20 * 1).ListAsync());
+#pragma warning restore CS0472 // The result of the expression is always the same since a value of this type is never equal to 'null'
+				var val1 = await (s.QueryOver<Person>().Select(p => p.Age *2).Where( p => p.Age == 20).SingleOrDefaultAsync<int>());
+
 				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));
+				Assert.That(persons6.Count, Is.EqualTo(1));
+				Assert.That(persons7.Count, Is.EqualTo(0));
+				Assert.That(val1, Is.EqualTo(40));
 			}
 		}
 	}

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

@@ -517,11 +517,20 @@ public void QueryOverArithmetic()
 				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();
+				var persons6 = s.QueryOver<Person>().Where(p => (p.Age * 2) / 2 + 20 - 20 == p.Age - p.Age + 20).List();
+#pragma warning disable CS0472 // The result of the expression is always the same since a value of this type is never equal to 'null'
+				var persons7 = s.QueryOver<Person>().Where(p => (p.Age * 2) / 2 + 20 - 20 == null || p.Age * 2 == 20 * 1).List();
+#pragma warning restore CS0472 // The result of the expression is always the same since a value of this type is never equal to 'null'
+				var val1 = s.QueryOver<Person>().Select(p => p.Age *2).Where( p => p.Age == 20).SingleOrDefault<int>();
+
 				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));
+				Assert.That(persons6.Count, Is.EqualTo(1));
+				Assert.That(persons7.Count, Is.EqualTo(0));
+				Assert.That(val1, Is.EqualTo(40));
 			}
 		}
 	}

src/NHibernate/Criterion/ConstantProjection.cs

@@ -13,7 +13,7 @@ namespace NHibernate.Criterion
 	public class ConstantProjection : SimpleProjection
 	{
 		private readonly object value;
-		private readonly TypedValue typedValue;
+		public TypedValue TypedValue { get; }
 
 		public ConstantProjection(object value) : this(value, NHibernateUtil.GuessType(value.GetType()))
 		{
@@ -22,7 +22,7 @@ public ConstantProjection(object value) : this(value, NHibernateUtil.GuessType(v
 		public ConstantProjection(object value, IType type)
 		{
 			this.value = value;
-			typedValue = new TypedValue(type, this.value);
+			TypedValue = new TypedValue(type, this.value);
 		}
 
 		public override bool IsAggregate
@@ -43,19 +43,19 @@ public override bool IsGrouped
 		public override SqlString ToSqlString(ICriteria criteria, int position, ICriteriaQuery criteriaQuery)
 		{
 			return new SqlString(
-				criteriaQuery.NewQueryParameter(typedValue).Single(),
+				criteriaQuery.NewQueryParameter(TypedValue).Single(),
 				" as ",
 				GetColumnAliases(position, criteria, criteriaQuery)[0]);
 		}
 
 		public override IType[] GetTypes(ICriteria criteria, ICriteriaQuery criteriaQuery)
 		{
-			return new IType[] { typedValue.Type };
+			return new IType[] { TypedValue.Type };
 		}
 
 		public override TypedValue[] GetTypedValues(ICriteria criteria, ICriteriaQuery criteriaQuery)
 		{
-			return new TypedValue[] { typedValue };
+			return new TypedValue[] { TypedValue };
 		}
 	}
 }

src/NHibernate/Impl/ExpressionProcessor.cs

@@ -7,6 +7,7 @@
 using System.Text.RegularExpressions;
 using NHibernate.Criterion;
 using NHibernate.Dialect.Function;
+using NHibernate.Engine;
 using NHibernate.Type;
 using NHibernate.Util;
 using Expression = System.Linq.Expressions.Expression;
@@ -89,16 +90,18 @@ public Order CreateOrder(Func<string, Order> orderStringDelegate, Func<IProjecti
 
 			/// <summary>
 			/// Retrieve the property name from a supplied PropertyProjection
-			/// Note:  throws if the supplied IProjection is not a PropertyProjection
+			/// Note:  throws if the supplied IProjection is not a IPropertyProjection
 			/// </summary>
 			public string AsProperty()
 			{
 				if (_property != null) return _property;
 
-				var propertyProjection = _projection as PropertyProjection;
+				var propertyProjection = _projection as IPropertyProjection;
 				if (propertyProjection == null) throw new InvalidOperationException("Cannot determine property for " + _projection);
 				return propertyProjection.PropertyName;
 			}
+
+			internal bool IsConstant(out ConstantProjection value) => (value = _projection as ConstantProjection) != null;
 		}
 
 		private static readonly Dictionary<ExpressionType, Func<ProjectionInfo, object, ICriterion>> _simpleExpressionCreators;
@@ -263,7 +266,8 @@ public static object FindValue(Expression expression)
 		public static ProjectionInfo FindMemberProjection(Expression expression)
 		{
 			if (!IsMemberExpression(expression))
-				return AsArithmeticExpression(expression) ?? ProjectionInfo.ForProjection(Projections.Constant(FindValue(expression)));
+				return AsArithmeticProjection(expression)
+					?? ProjectionInfo.ForProjection(Projections.Constant(FindValue(expression), NHibernateUtil.GuessType(expression.Type)));
 
 			var unwrapExpression = UnwrapConvertExpression(expression);
 			if (unwrapExpression != null)
@@ -281,14 +285,14 @@ public static ProjectionInfo FindMemberProjection(Expression expression)
 					return ProjectionInfo.ForProjection(processor(methodCallExpression));
 				}
 			}
-		    var memberExpression = expression as MemberExpression;
-            if (memberExpression != null)
+			var memberExpression = expression as MemberExpression;
+			if (memberExpression != null)
 			{
-                var signature = Signature(memberExpression.Member);
+				var signature = Signature(memberExpression.Member);
 				Func<Expression, IProjection> processor;
 				if (_customProjectionProcessors.TryGetValue(signature, out processor))
 				{
-                    return ProjectionInfo.ForProjection(processor(memberExpression));
+					return ProjectionInfo.ForProjection(processor(memberExpression));
 				}
 			}
 
@@ -317,7 +321,7 @@ private static bool IsSupportedUnaryExpression(UnaryExpression expression)
 			return expression.NodeType == ExpressionType.Negate;
 		}
 
-		private static ProjectionInfo AsArithmeticExpression(Expression expression)
+		private static ProjectionInfo AsArithmeticProjection(Expression expression)
 		{
 			if (!(expression is BinaryExpression be))
 			{
@@ -328,7 +332,7 @@ private static ProjectionInfo AsArithmeticExpression(Expression expression)
 				}
 
 				var unwrapExpression = UnwrapConvertExpression(expression);
-				return unwrapExpression != null ? AsArithmeticExpression(unwrapExpression) : null;
+				return unwrapExpression != null ? AsArithmeticProjection(unwrapExpression) : null;
 			}
 
 			if (!_binaryArithmethicTemplates.TryGetValue(be.NodeType, out var template))
@@ -565,21 +569,12 @@ private static object ConvertType(object value, System.Type type)
 			throw new ArgumentException(string.Format("Cannot convert '{0}' to {1}", value, type));
 		}
 
-		private static ICriterion ProcessSimpleExpression(BinaryExpression be)
-		{
-			if (be.Left.NodeType == ExpressionType.Call && ((MethodCallExpression)be.Left).Method.Name == "CompareString")
-				return ProcessVisualBasicStringComparison(be);
-
-			return ProcessSimpleExpression(be.Left, be.Right, be.NodeType);
-		}
-
-		private static ICriterion ProcessSimpleExpression(Expression left, Expression right, ExpressionType nodeType)
+		private static ICriterion ProcessSimpleExpression(Expression left, TypedValue rightValue, ExpressionType nodeType)
 		{
 			ProjectionInfo property = FindMemberProjection(left);
 			System.Type propertyType = FindMemberType(left);
 
-			object value = FindValue(right);
-			value = ConvertType(value, propertyType);
+			var value = ConvertType(rightValue.Value, propertyType);
 
 			if (value == null)
 				return ProcessSimpleNullExpression(property, nodeType);
@@ -591,14 +586,17 @@ private static ICriterion ProcessSimpleExpression(Expression left, Expression ri
 			return simpleExpressionCreator(property, value);
 		}
 
-		private static ICriterion ProcessVisualBasicStringComparison(BinaryExpression be)
+		private static ICriterion ProcessAsVisualBasicStringComparison(Expression left, ExpressionType nodeType)
 		{
-			var methodCall = (MethodCallExpression)be.Left;
+			if (left.NodeType != ExpressionType.Call)
+			{
+				return null;
+			}
 
-			if (IsMemberExpression(methodCall.Arguments[1]))
-				return ProcessMemberExpression(methodCall.Arguments[0], methodCall.Arguments[1], be.NodeType);
-			else
-				return ProcessSimpleExpression(methodCall.Arguments[0], methodCall.Arguments[1], be.NodeType);
+			var methodCall = (MethodCallExpression) left;
+			return methodCall.Method.Name == "CompareString"
+				? ProcessMemberExpression(methodCall.Arguments[0], methodCall.Arguments[1], nodeType)
+				: null;
 		}
 
 		private static ICriterion ProcessSimpleNullExpression(ProjectionInfo property, ExpressionType expressionType)
@@ -613,15 +611,15 @@ private static ICriterion ProcessSimpleNullExpression(ProjectionInfo property, E
 			throw new ArgumentException("Cannot supply null value to operator " + expressionType, nameof(expressionType));
 		}
 
-		private static ICriterion ProcessMemberExpression(BinaryExpression be)
-		{
-			return ProcessMemberExpression(be.Left, be.Right, be.NodeType);
-		}
-
 		private static ICriterion ProcessMemberExpression(Expression left, Expression right, ExpressionType nodeType)
 		{
 			ProjectionInfo leftProperty = FindMemberProjection(left);
 			ProjectionInfo rightProperty = FindMemberProjection(right);
+			if (rightProperty.IsConstant(out var constProjection))
+			{
+				return ProcessAsVisualBasicStringComparison(left, nodeType)
+						?? ProcessSimpleExpression(left, constProjection.TypedValue, nodeType);
+			}
 
 			Func<ProjectionInfo, ProjectionInfo, ICriterion> propertyExpressionCreator;
 			if (!_propertyExpressionCreators.TryGetValue(nodeType, out propertyExpressionCreator))
@@ -660,11 +658,7 @@ private static ICriterion ProcessBinaryExpression(BinaryExpression expression)
 				case ExpressionType.GreaterThanOrEqual:
 				case ExpressionType.LessThan:
 				case ExpressionType.LessThanOrEqual:
-					if (IsMemberExpression(expression.Right))
-						return ProcessMemberExpression(expression);
-					else
-						return ProcessSimpleExpression(expression);
-
+					return ProcessMemberExpression(expression.Left, expression.Right, expression.NodeType);
 				default:
 					throw new NotImplementedException("Unhandled binary expression: " + expression.NodeType + ", " + expression);
 			}