Simplify AND and OR

When constructing `AndAlso` and `OrElse` expressions, perform some basic local
simplifications.

Author: ranma42

src/EFCore.Relational/Query/ISqlExpressionFactory.cs

@@ -57,12 +57,14 @@ public interface ISqlExpressionFactory
     /// <param name="left">The left operand of binary operation.</param>
     /// <param name="right">The right operand of binary operation.</param>
     /// <param name="typeMapping">A type mapping to be assigned to the created expression.</param>
+    /// <param name="existingExpr">An optional expression that can be re-used if it matches the new expression.</param>
     /// <returns>A <see cref="SqlExpression" /> with the given arguments.</returns>
     SqlExpression? MakeBinary(
         ExpressionType operatorType,
         SqlExpression left,
         SqlExpression right,
-        RelationalTypeMapping? typeMapping);
+        RelationalTypeMapping? typeMapping,
+        SqlExpression? existingExpr = null);
 
     // Comparison
     /// <summary>

src/EFCore.Relational/Query/SqlExpressionFactory.cs

@@ -395,8 +395,25 @@ private SqlExpression ApplyTypeMappingOnJsonScalar(
         ExpressionType operatorType,
         SqlExpression left,
         SqlExpression right,
-        RelationalTypeMapping? typeMapping)
+        RelationalTypeMapping? typeMapping,
+        SqlExpression? existingExpr = null)
     {
+        if (existingExpr is SqlBinaryExpression binaryExpr
+            && binaryExpr.OperatorType == operatorType
+            && left == binaryExpr.Left
+            && right == binaryExpr.Right)
+        {
+            return existingExpr;
+        }
+
+        switch (operatorType)
+        {
+            case ExpressionType.AndAlso:
+                return AndAlso(left, right);
+            case ExpressionType.OrElse:
+                return OrElse(left, right);
+        }
+
         if (!SqlBinaryExpression.IsValidOperator(operatorType))
         {
             return null;
@@ -447,11 +464,78 @@ public virtual SqlExpression LessThanOrEqual(SqlExpression left, SqlExpression r
 
     /// <inheritdoc />
     public virtual SqlExpression AndAlso(SqlExpression left, SqlExpression right)
-        => MakeBinary(ExpressionType.AndAlso, left, right, null)!;
+    {
+        SqlExpression result;
+
+        // false && x -> false
+        // x && true -> x
+        // x && x -> x
+        if (left is SqlConstantExpression { Value: false }
+            || right is SqlConstantExpression { Value: true }
+            || left.Equals(right))
+        {
+            result = left;
+        }
+        // true && x -> x
+        // x && false -> false
+        else if (left is SqlConstantExpression { Value: true } || right is SqlConstantExpression { Value: false })
+        {
+            result = right;
+        }
+        // x is null && x is not null -> false
+        // x is not null && x is null -> false
+        else if (left is SqlUnaryExpression { OperatorType: ExpressionType.Equal or ExpressionType.NotEqual } leftUnary
+            && right is SqlUnaryExpression { OperatorType: ExpressionType.Equal or ExpressionType.NotEqual } rightUnary
+            && leftUnary.Operand.Equals(rightUnary.Operand))
+        {
+            // the case in which left and right are the same expression is handled above
+            result = Constant(false);
+        }
+        else
+        {
+            result = new SqlBinaryExpression(ExpressionType.AndAlso, left, right, typeof(bool), null);
+        }
+
+        return ApplyTypeMapping(result, _boolTypeMapping);
+    }
 
     /// <inheritdoc />
     public virtual SqlExpression OrElse(SqlExpression left, SqlExpression right)
-        => MakeBinary(ExpressionType.OrElse, left, right, null)!;
+    {
+        SqlExpression result;
+
+        // true || x -> true
+        // x || false -> x
+        // x || x -> x
+        if (left is SqlConstantExpression { Value: true }
+            || right is SqlConstantExpression { Value: false }
+            || left.Equals(right))
+        {
+            result = left;
+        }
+        // false || x -> x
+        // x || true -> true
+        else if (left is SqlConstantExpression { Value: false }
+            || right is SqlConstantExpression { Value: true })
+        {
+            result = right;
+        }
+        // x is null || x is not null -> true
+        // x is not null || x is null -> true
+        else if (left is SqlUnaryExpression { OperatorType: ExpressionType.Equal or ExpressionType.NotEqual } leftUnary
+            && right is SqlUnaryExpression { OperatorType: ExpressionType.Equal or ExpressionType.NotEqual } rightUnary
+            && leftUnary.Operand.Equals(rightUnary.Operand))
+        {
+            // the case in which left and right are the same expression is handled above
+            result = Constant(true);
+        }
+        else
+        {
+            result = new SqlBinaryExpression(ExpressionType.OrElse, left, right, typeof(bool), null);
+        }
+
+        return ApplyTypeMapping(result, _boolTypeMapping);
+    }
 
     /// <inheritdoc />
     public virtual SqlExpression Add(SqlExpression left, SqlExpression right, RelationalTypeMapping? typeMapping = null)