Invalid binary aggregation optimization regression

After upgrading from 2.6(.4) to 2.7(.2), a predicate interpretation/optimization problem occours when condition is in conjunctive normal form, and extra condition added in nested reverse form.

We use boolean constants to control how the predicate would behave under certain data driven scenarios. Constants are translated into SQL “1 = 1” or “1 = 0” accordingly, which is fine. The problem occours for example in cases like:

var isEmptyX = true, isEmptyY = false;
var includeZ = true, includeW = true;

(isEmptyX || x.Prop1 == [...]) && (isEmptyY || x.Prop2 == [...]) && ((includeZ && x.Field == EnumVal1) || (includeW && x.Field == EnumVal2))

The last nested past of this expression in 2.7.2 will translate into ...AND (1 == 1 AND 1 == 0 OR 1 == 1 AND Field == EnumVal2). If I switch the EnumVal1 equality check with the part EnumVal2 to be the last in the predicate, then it will generate ... AND Field == Enumval1 accordingly. Inspecting the Expression on query object it seems that parentheses dropped internally as well. This seems to be some kind of too optimistic optimization that replaces the other field access expression with constant boolean for no reason.

Setting used: Configuration.Linq.UseBinaryAggregateExpression = true

(this setting is a must for use, because some sub-system generates huge (1000+) parameter-based predicates that would cause stack overflow otherwise)

Thanks in advance.

Environment details

linq2db version: 2.7.2 Database Server: SQL Server 2017 Database Provider: SqlClient Operating system: Window 10 1804 .NET Framework: 4.7.2

[sdanyliv]

@detoxhby, thanks. Wait for quick fix and bug-fix release.

[detoxhby]

It generates LinqService pair tests, this could be excluded (but generates good query though…).

using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using LinqToDB;
using LinqToDB.Common;
using Tests.Model;

namespace Tests.UserTests
{
	[TestFixture]
	public class Issue1750Tests : TestBase
	{
		[Test]
		public void Issue1750Test([DataSources(ProviderName.SqlServer2017)] string context)
		{
			var ubae = Configuration.Linq.UseBinaryAggregateExpression;

			try
			{
				Configuration.Linq.UseBinaryAggregateExpression = true;

				using (var db = GetDataContext(context))
				{
					// Arrange
					var childrenIn = (int[])null;
					var grandChildIn = GrandChild.Select(x => x.ParentID);					
					var includeX = true;
					var includeY = true;

					// Act
					var query = from p in db.Parent
								where
								(childrenIn == null || childrenIn.Contains(p.ParentID)) && (grandChildIn == null || grandChildIn.Contains(p.ParentID)) &&
								// this should be "(1 = 1 AND Value1 = 1) OR (1 = 1 AND Value1 = 2)"
								// or with proper normalization it should be "(Value1 = 1 OR Value1 = 2)"
								((includeX && p.Value1 == 1) || (includeY && p.Value1 == 2))
								select p;

					var querySQLText = query.ToString();

					// Assert
					Assert.False(
						querySQLText.TrimEnd().EndsWith("(1 = 1 AND [p].[Value1] = 2)", StringComparison.OrdinalIgnoreCase),
						$"Invalid predicate normalization: {querySQLText}"
					);
				}
			}
			finally
			{
				Configuration.Linq.UseBinaryAggregateExpression = ubae;
			}
		}
	}
}