public virtual MySqlColumnAliasReferenceExpression Update(
[NotNull] string alias,
[NotNull] SqlExpression expression)
=> alias == Alias &&
expression.Equals(Expression)
? this
: new MySqlColumnAliasReferenceExpression(alias, expression, Type, TypeMapping);
public override bool Equals(object other)
{
if (other is SpannerDateExtractExpression o)
{
return(_fromFragment.Equals(o._fromFragment) && _value.Equals(o._value));
}
return(false);
}
public override bool Equals(object other)
{
if (other is SpannerIntervalExpression o)
{
return(_intervalFragment.Equals(o._intervalFragment) && _value.Equals(o._value) && _intervalNameFragment.Equals(o._intervalNameFragment));
}
return(false);
}
public override bool Equals(object other)
{
if (other is SpannerTimestampExtractExpression o)
{
return(_fromFragment.Equals(o._fromFragment) && _value.Equals(o._value) && _timezoneFragment.Equals(o._timezoneFragment));
}
return(false);
}
private SqlStatement GetSqlStatement(SqlExpression query)
{
//tood: add iequatable to the query, table and expression classes
if (!query.Equals(_query))
{
_query = query;
_sqlStatement = query;
}
return(_sqlStatement);
}
private bool Equals(MySqlCollateExpression other) => string.Equals(_charset, other._charset, StringComparison.OrdinalIgnoreCase) && string.Equals(_collation, other._collation, StringComparison.OrdinalIgnoreCase) && _valueExpression.Equals(other._valueExpression);
private SqlExpression SimplifyBinaryExpression(
ExpressionType operatorType,
SqlExpression left,
SqlExpression right,
RelationalTypeMapping typeMapping)
{
switch (operatorType)
{
case ExpressionType.AndAlso:
case ExpressionType.OrElse:
var leftUnary = left as SqlUnaryExpression;
var rightUnary = right as SqlUnaryExpression;
if (leftUnary != null &&
rightUnary != null &&
(leftUnary.OperatorType == ExpressionType.Equal || leftUnary.OperatorType == ExpressionType.NotEqual) &&
(rightUnary.OperatorType == ExpressionType.Equal || rightUnary.OperatorType == ExpressionType.NotEqual) &&
leftUnary.Operand.Equals(rightUnary.Operand))
{
// a is null || a is null -> a is null
// a is not null || a is not null -> a is not null
// a is null && a is null -> a is null
// a is not null && a is not null -> a is not null
// a is null || a is not null -> true
// a is null && a is not null -> false
return(leftUnary.OperatorType == rightUnary.OperatorType
? (SqlExpression)leftUnary
: SqlExpressionFactory.Constant(operatorType == ExpressionType.OrElse, typeMapping));
}
return(SimplifyLogicalSqlBinaryExpression(
operatorType,
left,
right,
typeMapping));
case ExpressionType.Equal:
case ExpressionType.NotEqual:
var leftConstant = left as SqlConstantExpression;
var rightConstant = right as SqlConstantExpression;
var leftNullConstant = leftConstant != null && leftConstant.Value == null;
var rightNullConstant = rightConstant != null && rightConstant.Value == null;
if (leftNullConstant || rightNullConstant)
{
return(SimplifyNullComparisonExpression(
operatorType,
left,
right,
leftNullConstant,
rightNullConstant,
typeMapping));
}
var leftBoolConstant = left.Type == typeof(bool) ? leftConstant : null;
var rightBoolConstant = right.Type == typeof(bool) ? rightConstant : null;
if (leftBoolConstant != null || rightBoolConstant != null)
{
return(SimplifyBoolConstantComparisonExpression(
operatorType,
left,
right,
leftBoolConstant,
rightBoolConstant,
typeMapping));
}
// only works when a is not nullable
// a == a -> true
// a != a -> false
if ((left is LikeExpression ||
left is ColumnExpression columnExpression && !columnExpression.IsNullable) &&
left.Equals(right))
{
return(SqlExpressionFactory.Constant(operatorType == ExpressionType.Equal, typeMapping));
}
break;
}
return(SqlExpressionFactory.MakeBinary(operatorType, left, right, typeMapping));
}
