Merge pull request #212 from servicetitan/upstream/precise-bool-expression-converter

BooleanExpressionConverter: use precise optimization

Author: alex-kulakov

Extensions/Xtensive.Orm.BulkOperations/Internals/BaseSqlVisitor.cs

@@ -516,12 +516,16 @@ public virtual void Visit(SqlWhile node)
       VisitInternal(node.Statement);
     }
 
-
     public virtual void Visit(SqlFragment node)
     {
       VisitInternal(node.Expression);
     }
 
+    public virtual void Visit(SqlMetadata node)
+    {
+      VisitInternal(node.Expression);
+    }
+
     #region Non-public methods
 
     private void VisitInternal(ISqlNode node)

Orm/Xtensive.Orm.Tests/Linq/DistinctTest.cs

@@ -399,5 +399,26 @@ public void DistinctSkipTakeTest()
       Assert.IsTrue(expected.SequenceEqual(result));
       Assert.Greater(result.ToList().Count, 0);
     }
+
+    [Test]
+    public void DistinctByBoolExpression()
+    {
+      var result = Session.Query.All<Invoice>().Select(c => c.Status == (InvoiceStatus) 1)
+        .Distinct()
+        .ToArray();
+
+      CollectionAssert.AreEquivalent(new[] {false, true}, result);
+    }
+
+    [Test]
+    public void DistinctByBoolExpressionComplex()
+    {
+      var result = Session.Query.All<Invoice>()
+        .Select(c => c.Status == (InvoiceStatus) 1 || c.Status == (InvoiceStatus) 2)
+        .Distinct()
+        .ToArray();
+
+      CollectionAssert.AreEquivalent(new[] {false, true}, result);
+    }
   }
 }

Orm/Xtensive.Orm.Tests/Linq/GroupByTest.cs

@@ -1021,6 +1021,37 @@ public void GroupWithJoinTest()
       QueryDumper.Dump(query);
     }
 
+    [Test]
+    public void GroupByBoolExpression()
+    {
+      var query = Session.Query.All<Invoice>();
+      var falseResult = query.Count(c => c.Status != (InvoiceStatus) 1);
+      var trueResult = query.Count(c => c.Status == (InvoiceStatus) 1);
+
+      var result = query.GroupBy(c => c.Status == (InvoiceStatus) 1)
+        .Select(c => new {Value = c.Key, Count = c.Count()})
+        .ToArray();
+
+      Assert.AreEqual(falseResult, result.Single(i => !i.Value).Count);
+      Assert.AreEqual(trueResult, result.Single(i => i.Value).Count);
+    }
+
+    [Test]
+    public void GroupByBoolExpressionComplex()
+    {
+      var query = Session.Query.All<Invoice>();
+      var falseResult = query.Count(c => !(c.Status == (InvoiceStatus) 1 || c.Status == (InvoiceStatus) 2));
+      var trueResult = query.Count(c => c.Status == (InvoiceStatus) 1 || c.Status == (InvoiceStatus) 2);
+
+      var result = query
+        .GroupBy(c => c.Status == (InvoiceStatus) 1 || c.Status == (InvoiceStatus) 2)
+        .Select(c => new {Value = c.Key, Count = c.Count()})
+        .ToArray();
+
+      Assert.AreEqual(falseResult, result.Single(i => !i.Value).Count);
+      Assert.AreEqual(trueResult, result.Single(i => i.Value).Count);
+    }
+
     private void DumpGrouping<TKey, TValue>(IQueryable<IGrouping<TKey, TValue>> result)
     {
       DumpGrouping(result, false);

Orm/Xtensive.Orm.Tests/Linq/OrderByTest.cs

@@ -316,5 +316,24 @@ public void ThenByTest()
       Assert.That(result, Is.Not.Empty);
       Assert.IsTrue(expected.SequenceEqual(result));
     }
+
+    [Test]
+    public void OrderByBoolExpression()
+    {
+      var result = Session.Query.All<Invoice>().OrderBy(c => c.Status == (InvoiceStatus) 1)
+        .Select(c => c.Status)
+        .ToArray();
+      Assert.AreEqual(result.Last(), (InvoiceStatus) 1);
+    }
+
+    [Test]
+    public void OrderByBoolExpressionComplex()
+    {
+      var result = Session.Query.All<Invoice>()
+        .OrderBy(c => c.Status == (InvoiceStatus) 1 || c.Status == (InvoiceStatus) 2)
+        .Select(c => c.Status)
+        .ToArray();
+      Assert.Contains(result.Last(), new[] { (InvoiceStatus) 1, (InvoiceStatus) 2 });
+    }
   }
-}
+}

Orm/Xtensive.Orm.Tests/Linq/WhereTest.cs

@@ -1326,5 +1326,29 @@ public void ApplyTest()
         .Where(customer => customer.Invoices.Any(i => i.Commission > 0.30m));
       Assert.IsTrue(expected.SequenceEqual(actual));
     }
+
+    [Test]
+    public void WhereBoolEquals()
+    {
+      var expected = Session.Query.All<Invoice>().Count(c => c.Status != (InvoiceStatus) 1);
+      // ReSharper disable once ReplaceWithSingleCallToCount
+      var actual = Session.Query.All<Invoice>().Where(c => (c.Status == (InvoiceStatus) 1) == false).Count();
+
+      Assert.AreEqual(expected, actual);
+    }
+
+    [Test]
+    public void WhereBoolEqualsComplex()
+    {
+      var expected = Session.Query.All<Invoice>()
+        .Count(c => !(c.Status == (InvoiceStatus) 1 || c.Status == (InvoiceStatus) 2));
+
+      // ReSharper disable once ReplaceWithSingleCallToCount
+      var actual = Session.Query.All<Invoice>()
+        .Where(c => (c.Status == (InvoiceStatus) 1 || c.Status == (InvoiceStatus) 2) == false)
+        .Count();
+
+      Assert.AreEqual(expected, actual);
+    }
   }
 }

Orm/Xtensive.Orm/Orm/Providers/Expressions/BooleanExpressionConverter.cs

@@ -4,6 +4,7 @@
 // Created by: Denis Krjuchkov
 // Created:    2009.08.17
 
+using System.Collections.Generic;
 using System.Linq;
 using Xtensive.Reflection;
 using Xtensive.Sql;
@@ -13,46 +14,36 @@ namespace Xtensive.Orm.Providers
 {
   internal sealed class BooleanExpressionConverter
   {
+    private static readonly object IntToBooleanTag = new();
+    private static readonly object BooleanToIntTag = new();
+
     private readonly SqlValueType booleanType;
 
     public SqlExpression IntToBoolean(SqlExpression expression)
     {
       // optimization: omitting IntToBoolean(BooleanToInt(x)) sequences
-      if (expression.NodeType==SqlNodeType.Cast) {
-        var operand = ((SqlCast) expression).Operand;
-        if (operand.NodeType==SqlNodeType.Case) {
-          var _case = (SqlCase) operand;
-          if (_case.Count == 1) {
-            var firstCaseItem = _case.First();
-            var whenTrue = firstCaseItem.Value as SqlLiteral<int>;
-            var whenFalse = _case.Else as SqlLiteral<int>;
-            if (!ReferenceEquals(whenTrue, null)
-             && !ReferenceEquals(whenFalse, null)
-             && whenTrue.Value==1
-             && whenFalse.Value==0)
-              return firstCaseItem.Key;
-          }
-        }
+      if (expression.NodeType == SqlNodeType.Metadata &&
+          expression is SqlMetadata metadata &&
+          metadata.Value == BooleanToIntTag) {
+        return ((SqlCase) ((SqlCast) metadata.Expression).Operand).First().Key;
       }
 
-      return SqlDml.Equals(expression, 1);
+      return SqlDml.Metadata(SqlDml.Equals(expression, 1), IntToBooleanTag);
     }
 
     public SqlExpression BooleanToInt(SqlExpression expression)
     {
       // optimization: omitting BooleanToInt(IntToBoolean(x)) sequences
-      if (expression.NodeType==SqlNodeType.Equals) {
-        var binary = (SqlBinary) expression;
-        var left = binary.Left;
-        var right = binary.Right as SqlLiteral<int>;
-        if (!ReferenceEquals(right, null) && right.Value==1)
-          return left;
+      if (expression.NodeType == SqlNodeType.Metadata &&
+          expression is SqlMetadata metadata &&
+          metadata.Value == IntToBooleanTag) {
+        return ((SqlBinary) metadata.Expression).Left;
       }
 
       var result = SqlDml.Case();
       result.Add(expression, 1);
       result.Else = 0;
-      return SqlDml.Cast(result, booleanType);
+      return SqlDml.Metadata(SqlDml.Cast(result, booleanType), BooleanToIntTag);
     }
 
     public BooleanExpressionConverter(StorageDriver driver)

Orm/Xtensive.Orm/Orm/Providers/SqlSelectProcessor.cs

@@ -493,6 +493,11 @@ public void Visit(SqlUnary node)
         Visit(node.Operand);
     }
 
+    public void Visit(SqlMetadata node)
+    {
+      Visit(node.Expression);
+    }
+
     public void Visit(SqlUpdate node)
     {
       if (node.From!=null)

Orm/Xtensive.Orm/Sql/Compiler/SqlCompiler.cs

@@ -1380,6 +1380,11 @@ public virtual void Visit(SqlUnary node)
       }
     }
 
+    public virtual void Visit(SqlMetadata node)
+    {
+      node.Expression.AcceptVisitor(this);
+    }
+
     public virtual void Visit(SqlUpdate node)
     {
       VisitUpdateDefault(node);

Orm/Xtensive.Orm/Sql/Dml/Expressions/SqlMetadata.cs

@@ -0,0 +1,43 @@
+// Copyright (C) 2022 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
+
+using Xtensive.Core;
+
+namespace Xtensive.Sql.Dml
+{
+  /// <summary>
+  /// Arbitrary metadata that could be attached to SQL expression tree.
+  /// </summary>
+  public class SqlMetadata : SqlExpression
+  {
+    public SqlExpression Expression { get; private set; }
+
+    public object Value { get; private set; }
+
+    public override void ReplaceWith(SqlExpression expression)
+    {
+      ArgumentValidator.EnsureArgumentNotNull(expression, nameof(expression));
+      ArgumentValidator.EnsureArgumentIs<SqlMetadata>(expression, nameof(expression));
+      var source = (SqlMetadata) expression;
+      NodeType = source.NodeType;
+      Expression = source.Expression;
+      Value = source.Value;
+    }
+
+    internal override object Clone(SqlNodeCloneContext context) =>
+      context.NodeMapping.TryGetValue(this, out var clone)
+        ? clone
+        : context.NodeMapping[this] = new SqlMetadata((SqlExpression) Expression.Clone(context), Value);
+
+    public override void AcceptVisitor(ISqlVisitor visitor) => visitor.Visit(this);
+
+    // Constructors
+
+    internal SqlMetadata(SqlExpression expression, object value) : base(SqlNodeType.Metadata)
+    {
+      Expression = expression;
+      Value = value;
+    }
+  }
+}

Orm/Xtensive.Orm/Sql/Interfaces/ISqlVisitor.cs

@@ -98,6 +98,7 @@ public interface ISqlVisitor
     void Visit(SqlSelect node);
     void Visit(SqlSubQuery node);
     void Visit(SqlUnary node);
+    void Visit(SqlMetadata node);
     void Visit(SqlUpdate node);
     void Visit(SqlUserColumn node);
     void Visit(SqlUserFunctionCall node);