private SqlExpression OptimizeCompareTo(
SqlBinaryExpression sqlBinaryExpression,
int intValue,
CaseExpression caseExpression)
{
var testLeft = ((SqlBinaryExpression)caseExpression.WhenClauses[0].Test).Left;
var testRight = ((SqlBinaryExpression)caseExpression.WhenClauses[0].Test).Right;
var operatorType = sqlBinaryExpression.Right is SqlConstantExpression
? sqlBinaryExpression.OperatorType
: sqlBinaryExpression.OperatorType switch
{
ExpressionType.GreaterThan => ExpressionType.LessThan,
ExpressionType.GreaterThanOrEqual => ExpressionType.LessThanOrEqual,
ExpressionType.LessThan => ExpressionType.GreaterThan,
ExpressionType.LessThanOrEqual => ExpressionType.GreaterThanOrEqual,
_ => sqlBinaryExpression.OperatorType
};
switch (operatorType)
{
// CompareTo(a, b) != 0 -> a != b
// CompareTo(a, b) != 1 -> a <= b
// CompareTo(a, b) != -1 -> a >= b
case ExpressionType.NotEqual:
return((SqlExpression)Visit(intValue switch
{
0 => _sqlExpressionFactory.NotEqual(testLeft, testRight),
1 => _sqlExpressionFactory.LessThanOrEqual(testLeft, testRight),
_ => _sqlExpressionFactory.GreaterThanOrEqual(testLeft, testRight),
}));
private SqlBinaryExpression VisitSqlBinaryExpression(SqlBinaryExpression sqlBinaryExpression)
{
_isNullable = false;
var newLeft = (SqlExpression)Visit(sqlBinaryExpression.Left);
var leftNullable = _isNullable;
_isNullable = false;
var newRight = (SqlExpression)Visit(sqlBinaryExpression.Right);
var rightNullable = _isNullable;
if (sqlBinaryExpression.OperatorType == ExpressionType.Coalesce)
{
_isNullable = leftNullable && rightNullable;
return(sqlBinaryExpression.Update(newLeft, newRight));
}
if (sqlBinaryExpression.OperatorType == ExpressionType.Equal ||
sqlBinaryExpression.OperatorType == ExpressionType.NotEqual)
{
var leftUnary = newLeft as SqlUnaryExpression;
var rightUnary = newRight as SqlUnaryExpression;
var leftNegated = leftUnary?.OperatorType == ExpressionType.Not;
var rightNegated = rightUnary?.OperatorType == ExpressionType.Not;
if (leftNegated)
{
newLeft = leftUnary.Operand;
}
if (rightNegated)
{
newRight = rightUnary.Operand;
}
// TODO: optimize this by looking at subcomponents, e.g. f(a, b) == null <=> a == null || b == null
var leftIsNull = _sqlExpressionFactory.IsNull(newLeft);
var rightIsNull = _sqlExpressionFactory.IsNull(newRight);
// doing a full null semantics rewrite - removing all nulls from truth table
_isNullable = false;
if (sqlBinaryExpression.OperatorType == ExpressionType.Equal)
{
if (!leftNullable && !rightNullable)
{
// a == b <=> !a == !b -> a == b
// !a == b <=> a == !b -> a != b
return(leftNegated == rightNegated
? _sqlExpressionFactory.Equal(newLeft, newRight)
: _sqlExpressionFactory.NotEqual(newLeft, newRight));
}
if (leftNullable && rightNullable)
{
// ?a == ?b <=> !(?a) == !(?b) -> [(a == b) && (a != null && b != null)] || (a == null && b == null))
// !(?a) == ?b <=> ?a == !(?b) -> [(a != b) && (a != null && b != null)] || (a == null && b == null)
return(leftNegated == rightNegated
? ExpandNullableEqualNullable(newLeft, newRight, leftIsNull, rightIsNull)
: ExpandNegatedNullableEqualNullable(newLeft, newRight, leftIsNull, rightIsNull));
}
if (leftNullable && !rightNullable)
{
// ?a == b <=> !(?a) == !b -> (a == b) && (a != null)
// !(?a) == b <=> ?a == !b -> (a != b) && (a != null)
return(leftNegated == rightNegated
? ExpandNullableEqualNonNullable(newLeft, newRight, leftIsNull)
: ExpandNegatedNullableEqualNonNullable(newLeft, newRight, leftIsNull));
}
if (rightNullable && !leftNullable)
{
// a == ?b <=> !a == !(?b) -> (a == b) && (b != null)
// !a == ?b <=> a == !(?b) -> (a != b) && (b != null)
return(leftNegated == rightNegated
? ExpandNullableEqualNonNullable(newLeft, newRight, rightIsNull)
: ExpandNegatedNullableEqualNonNullable(newLeft, newRight, rightIsNull));
}
}
if (sqlBinaryExpression.OperatorType == ExpressionType.NotEqual)
{
if (!leftNullable && !rightNullable)
{
// a != b <=> !a != !b -> a != b
// !a != b <=> a != !b -> a == b
return(leftNegated == rightNegated
? _sqlExpressionFactory.NotEqual(newLeft, newRight)
: _sqlExpressionFactory.Equal(newLeft, newRight));
}
if (leftNullable && rightNullable)
{
// ?a != ?b <=> !(?a) != !(?b) -> [(a != b) || (a == null || b == null)] && (a != null || b != null)
// !(?a) != ?b <=> ?a != !(?b) -> [(a == b) || (a == null || b == null)] && (a != null || b != null)
return(leftNegated == rightNegated
? ExpandNullableNotEqualNullable(newLeft, newRight, leftIsNull, rightIsNull)
: ExpandNegatedNullableNotEqualNullable(newLeft, newRight, leftIsNull, rightIsNull));
}
if (leftNullable)
{
// ?a != b <=> !(?a) != !b -> (a != b) || (a == null)
// !(?a) != b <=> ?a != !b -> (a == b) || (a == null)
return(leftNegated == rightNegated
? ExpandNullableNotEqualNonNullable(newLeft, newRight, leftIsNull)
: ExpandNegatedNullableNotEqualNonNullable(newLeft, newRight, leftIsNull));
}
if (rightNullable)
{
// a != ?b <=> !a != !(?b) -> (a != b) || (b == null)
// !a != ?b <=> a != !(?b) -> (a == b) || (b == null)
return(leftNegated == rightNegated
? ExpandNullableNotEqualNonNullable(newLeft, newRight, rightIsNull)
: ExpandNegatedNullableNotEqualNonNullable(newLeft, newRight, rightIsNull));
}
}
}
_isNullable = leftNullable || rightNullable;
return(sqlBinaryExpression.Update(newLeft, newRight));
}
protected override Expression VisitSqlBinary(SqlBinaryExpression sqlBinaryExpression)
{
Check.NotNull(sqlBinaryExpression, nameof(sqlBinaryExpression));
_isNullable = false;
var canOptimize = _canOptimize;
// for SqlServer we could also allow optimize on children of ExpressionType.Equal
// because they get converted to CASE blocks anyway, but for other providers it's incorrect
// once/if null semantics optimizations are provider-specific we can enable it
_canOptimize = _canOptimize && (sqlBinaryExpression.OperatorType == ExpressionType.AndAlso ||
sqlBinaryExpression.OperatorType == ExpressionType.OrElse);
var nonNullableColumns = new List <ColumnExpression>();
if (sqlBinaryExpression.OperatorType == ExpressionType.AndAlso)
{
nonNullableColumns = FindNonNullableColumns(sqlBinaryExpression.Left);
}
var newLeft = (SqlExpression)Visit(sqlBinaryExpression.Left);
var leftNullable = _isNullable;
_isNullable = false;
if (nonNullableColumns.Count > 0)
{
_nonNullableColumns.AddRange(nonNullableColumns);
}
var newRight = (SqlExpression)Visit(sqlBinaryExpression.Right);
var rightNullable = _isNullable;
foreach (var nonNullableColumn in nonNullableColumns)
{
_nonNullableColumns.Remove(nonNullableColumn);
}
if (sqlBinaryExpression.OperatorType == ExpressionType.Coalesce)
{
_isNullable = leftNullable && rightNullable;
_canOptimize = canOptimize;
return(sqlBinaryExpression.Update(newLeft, newRight));
}
if (sqlBinaryExpression.OperatorType == ExpressionType.Add &&
sqlBinaryExpression.Type == typeof(string))
{
if (leftNullable)
{
newLeft = newLeft is SqlConstantExpression
? _sqlExpressionFactory.Constant(string.Empty)
: newLeft is ColumnExpression || newLeft is SqlParameterExpression
? _sqlExpressionFactory.Coalesce(newLeft, _sqlExpressionFactory.Constant(string.Empty))
: newLeft;
}
if (rightNullable)
{
newRight = newRight is SqlConstantExpression
? _sqlExpressionFactory.Constant(string.Empty)
: newRight is ColumnExpression || newRight is SqlParameterExpression
? _sqlExpressionFactory.Coalesce(newRight, _sqlExpressionFactory.Constant(string.Empty))
: newRight;
}
return(sqlBinaryExpression.Update(newLeft, newRight));
}
if (sqlBinaryExpression.OperatorType == ExpressionType.Equal ||
sqlBinaryExpression.OperatorType == ExpressionType.NotEqual)
{
var leftConstantNull = newLeft is SqlConstantExpression leftConstant && leftConstant.Value == null;
var rightConstantNull = newRight is SqlConstantExpression rightConstant && rightConstant.Value == null;
// a == null -> a IS NULL
// a != null -> a IS NOT NULL
if (rightConstantNull)
{
_isNullable = false;
_canOptimize = canOptimize;
return(sqlBinaryExpression.OperatorType == ExpressionType.Equal
? _sqlExpressionFactory.IsNull(newLeft)
: _sqlExpressionFactory.IsNotNull(newLeft));
}
// null == a -> a IS NULL
// null != a -> a IS NOT NULL
if (leftConstantNull)
{
_isNullable = false;
_canOptimize = canOptimize;
return(sqlBinaryExpression.OperatorType == ExpressionType.Equal
? _sqlExpressionFactory.IsNull(newRight)
: _sqlExpressionFactory.IsNotNull(newRight));
}
var leftUnary = newLeft as SqlUnaryExpression;
var rightUnary = newRight as SqlUnaryExpression;
var leftNegated = leftUnary?.IsLogicalNot() == true;
var rightNegated = rightUnary?.IsLogicalNot() == true;
if (leftNegated)
{
newLeft = leftUnary.Operand;
}
if (rightNegated)
{
newRight = rightUnary.Operand;
}
var leftIsNull = _sqlExpressionFactory.IsNull(newLeft);
var rightIsNull = _sqlExpressionFactory.IsNull(newRight);
// optimized expansion which doesn't distinguish between null and false
if (canOptimize &&
sqlBinaryExpression.OperatorType == ExpressionType.Equal &&
!leftNegated &&
!rightNegated)
{
// when we use optimized form, the result can still be nullable
if (leftNullable && rightNullable)
{
_isNullable = true;
_canOptimize = canOptimize;
return(_sqlExpressionFactory.OrElse(
_sqlExpressionFactory.Equal(newLeft, newRight),
_sqlExpressionFactory.AndAlso(leftIsNull, rightIsNull)));
}
if ((leftNullable && !rightNullable) ||
(!leftNullable && rightNullable))
{
_isNullable = true;
_canOptimize = canOptimize;
return(_sqlExpressionFactory.Equal(newLeft, newRight));
}
}
// doing a full null semantics rewrite - removing all nulls from truth table
// this will NOT be correct once we introduce simplified null semantics
_isNullable = false;
_canOptimize = canOptimize;
if (sqlBinaryExpression.OperatorType == ExpressionType.Equal)
{
if (!leftNullable &&
!rightNullable)
{
// a == b <=> !a == !b -> a == b
// !a == b <=> a == !b -> a != b
return(leftNegated == rightNegated
? _sqlExpressionFactory.Equal(newLeft, newRight)
: _sqlExpressionFactory.NotEqual(newLeft, newRight));
}
if (leftNullable && rightNullable)
{
// ?a == ?b <=> !(?a) == !(?b) -> [(a == b) && (a != null && b != null)] || (a == null && b == null))
// !(?a) == ?b <=> ?a == !(?b) -> [(a != b) && (a != null && b != null)] || (a == null && b == null)
return(leftNegated == rightNegated
? ExpandNullableEqualNullable(newLeft, newRight, leftIsNull, rightIsNull)
: ExpandNegatedNullableEqualNullable(newLeft, newRight, leftIsNull, rightIsNull));
}
if (leftNullable && !rightNullable)
{
// ?a == b <=> !(?a) == !b -> (a == b) && (a != null)
// !(?a) == b <=> ?a == !b -> (a != b) && (a != null)
return(leftNegated == rightNegated
? ExpandNullableEqualNonNullable(newLeft, newRight, leftIsNull)
: ExpandNegatedNullableEqualNonNullable(newLeft, newRight, leftIsNull));
}
if (rightNullable && !leftNullable)
{
// a == ?b <=> !a == !(?b) -> (a == b) && (b != null)
// !a == ?b <=> a == !(?b) -> (a != b) && (b != null)
return(leftNegated == rightNegated
? ExpandNullableEqualNonNullable(newLeft, newRight, rightIsNull)
: ExpandNegatedNullableEqualNonNullable(newLeft, newRight, rightIsNull));
}
}
if (sqlBinaryExpression.OperatorType == ExpressionType.NotEqual)
{
if (!leftNullable &&
!rightNullable)
{
// a != b <=> !a != !b -> a != b
// !a != b <=> a != !b -> a == b
return(leftNegated == rightNegated
? _sqlExpressionFactory.NotEqual(newLeft, newRight)
: _sqlExpressionFactory.Equal(newLeft, newRight));
}
if (leftNullable && rightNullable)
{
// ?a != ?b <=> !(?a) != !(?b) -> [(a != b) || (a == null || b == null)] && (a != null || b != null)
// !(?a) != ?b <=> ?a != !(?b) -> [(a == b) || (a == null || b == null)] && (a != null || b != null)
return(leftNegated == rightNegated
? ExpandNullableNotEqualNullable(newLeft, newRight, leftIsNull, rightIsNull)
: ExpandNegatedNullableNotEqualNullable(newLeft, newRight, leftIsNull, rightIsNull));
}
if (leftNullable)
{
// ?a != b <=> !(?a) != !b -> (a != b) || (a == null)
// !(?a) != b <=> ?a != !b -> (a == b) || (a == null)
return(leftNegated == rightNegated
? ExpandNullableNotEqualNonNullable(newLeft, newRight, leftIsNull)
: ExpandNegatedNullableNotEqualNonNullable(newLeft, newRight, leftIsNull));
}
if (rightNullable)
{
// a != ?b <=> !a != !(?b) -> (a != b) || (b == null)
// !a != ?b <=> a != !(?b) -> (a == b) || (b == null)
return(leftNegated == rightNegated
? ExpandNullableNotEqualNonNullable(newLeft, newRight, rightIsNull)
: ExpandNegatedNullableNotEqualNonNullable(newLeft, newRight, rightIsNull));
}
}
}
_isNullable = leftNullable || rightNullable;
_canOptimize = canOptimize;
return(sqlBinaryExpression.Update(newLeft, newRight));
}
private SqlBinaryExpression VisitSqlBinaryExpression(SqlBinaryExpression sqlBinaryExpression)
{
_isNullable = false;
var nonNullableColumns = new List <ColumnExpression>();
if (sqlBinaryExpression.OperatorType == ExpressionType.AndAlso)
{
nonNullableColumns = FindNonNullableColumns(sqlBinaryExpression.Left);
}
var newLeft = (SqlExpression)Visit(sqlBinaryExpression.Left);
var leftNullable = _isNullable;
_isNullable = false;
if (nonNullableColumns.Count > 0)
{
_nonNullableColumns.AddRange(nonNullableColumns);
}
var newRight = (SqlExpression)Visit(sqlBinaryExpression.Right);
var rightNullable = _isNullable;
foreach (var nonNullableColumn in nonNullableColumns)
{
_nonNullableColumns.Remove(nonNullableColumn);
}
if (sqlBinaryExpression.OperatorType == ExpressionType.Coalesce)
{
_isNullable = leftNullable && rightNullable;
return(sqlBinaryExpression.Update(newLeft, newRight));
}
if (sqlBinaryExpression.OperatorType == ExpressionType.Equal ||
sqlBinaryExpression.OperatorType == ExpressionType.NotEqual)
{
var leftUnary = newLeft as SqlUnaryExpression;
var rightUnary = newRight as SqlUnaryExpression;
var leftNegated = leftUnary?.OperatorType == ExpressionType.Not;
var rightNegated = rightUnary?.OperatorType == ExpressionType.Not;
if (leftNegated)
{
newLeft = leftUnary.Operand;
}
if (rightNegated)
{
newRight = rightUnary.Operand;
}
var leftIsNull = _sqlExpressionFactory.IsNull(newLeft);
var rightIsNull = _sqlExpressionFactory.IsNull(newRight);
// doing a full null semantics rewrite - removing all nulls from truth table
// this will NOT be correct once we introduce simplified null semantics
_isNullable = false;
if (sqlBinaryExpression.OperatorType == ExpressionType.Equal)
{
if (!leftNullable &&
!rightNullable)
{
// a == b <=> !a == !b -> a == b
// !a == b <=> a == !b -> a != b
return(leftNegated == rightNegated
? _sqlExpressionFactory.Equal(newLeft, newRight)
: _sqlExpressionFactory.NotEqual(newLeft, newRight));
}
if (leftNullable && rightNullable)
{
// ?a == ?b <=> !(?a) == !(?b) -> [(a == b) && (a != null && b != null)] || (a == null && b == null))
// !(?a) == ?b <=> ?a == !(?b) -> [(a != b) && (a != null && b != null)] || (a == null && b == null)
return(leftNegated == rightNegated
? ExpandNullableEqualNullable(newLeft, newRight, leftIsNull, rightIsNull)
: ExpandNegatedNullableEqualNullable(newLeft, newRight, leftIsNull, rightIsNull));
}
if (leftNullable && !rightNullable)
{
// ?a == b <=> !(?a) == !b -> (a == b) && (a != null)
// !(?a) == b <=> ?a == !b -> (a != b) && (a != null)
return(leftNegated == rightNegated
? ExpandNullableEqualNonNullable(newLeft, newRight, leftIsNull)
: ExpandNegatedNullableEqualNonNullable(newLeft, newRight, leftIsNull));
}
if (rightNullable && !leftNullable)
{
// a == ?b <=> !a == !(?b) -> (a == b) && (b != null)
// !a == ?b <=> a == !(?b) -> (a != b) && (b != null)
return(leftNegated == rightNegated
? ExpandNullableEqualNonNullable(newLeft, newRight, rightIsNull)
: ExpandNegatedNullableEqualNonNullable(newLeft, newRight, rightIsNull));
}
}
if (sqlBinaryExpression.OperatorType == ExpressionType.NotEqual)
{
if (!leftNullable &&
!rightNullable)
{
// a != b <=> !a != !b -> a != b
// !a != b <=> a != !b -> a == b
return(leftNegated == rightNegated
? _sqlExpressionFactory.NotEqual(newLeft, newRight)
: _sqlExpressionFactory.Equal(newLeft, newRight));
}
if (leftNullable && rightNullable)
{
// ?a != ?b <=> !(?a) != !(?b) -> [(a != b) || (a == null || b == null)] && (a != null || b != null)
// !(?a) != ?b <=> ?a != !(?b) -> [(a == b) || (a == null || b == null)] && (a != null || b != null)
return(leftNegated == rightNegated
? ExpandNullableNotEqualNullable(newLeft, newRight, leftIsNull, rightIsNull)
: ExpandNegatedNullableNotEqualNullable(newLeft, newRight, leftIsNull, rightIsNull));
}
if (leftNullable)
{
// ?a != b <=> !(?a) != !b -> (a != b) || (a == null)
// !(?a) != b <=> ?a != !b -> (a == b) || (a == null)
return(leftNegated == rightNegated
? ExpandNullableNotEqualNonNullable(newLeft, newRight, leftIsNull)
: ExpandNegatedNullableNotEqualNonNullable(newLeft, newRight, leftIsNull));
}
if (rightNullable)
{
// a != ?b <=> !a != !(?b) -> (a != b) || (b == null)
// !a != ?b <=> a != !(?b) -> (a == b) || (b == null)
return(leftNegated == rightNegated
? ExpandNullableNotEqualNonNullable(newLeft, newRight, rightIsNull)
: ExpandNegatedNullableNotEqualNonNullable(newLeft, newRight, rightIsNull));
}
}
}
_isNullable = leftNullable || rightNullable;
return(sqlBinaryExpression.Update(newLeft, newRight));
}