public void VisitSqlIsNullExpression_RevisitingTerminatesAfterInnerChanges_WithoutOuterChanges()
{
var inner = Expression.Constant(0);
var isNullExpression = new SqlIsNullExpression(inner);
var fakeResolvedInner = new SqlLiteralExpression(1);
_resolverMock.Expect(mock => mock.ResolveConstantExpression(inner)).Return(fakeResolvedInner);
_entityIdentityResolverMock
.Expect(mock => mock.ResolvePotentialEntityComparison(Arg <SqlIsNullExpression> .Is.Anything))
.Return(null)
.WhenCalled(mi => mi.ReturnValue = mi.Arguments[0]);
_compoundComparisonSplitterMock
.Expect(mock => mock.SplitPotentialCompoundComparison(Arg <SqlIsNullExpression> .Is.Anything))
.Return(null)
.WhenCalled(mi => mi.ReturnValue = mi.Arguments[0]);
// No revisiting
var result = _visitor.Visit(isNullExpression);
_resolverMock.VerifyAllExpectations();
_entityIdentityResolverMock.VerifyAllExpectations();
_compoundComparisonSplitterMock.VerifyAllExpectations();
Assert.That(result, Is.TypeOf <SqlIsNullExpression> ());
Assert.That(((SqlIsNullExpression)result).Expression, Is.SameAs(fakeResolvedInner));
}
public void ResolvePotentialEntityComparison_SqlIsNullExpression_NonEntities_ReturnsSameExpression()
{
var sqlIsNullExpression = new SqlIsNullExpression(Expression.Constant(0));
var result = _entityIdentityResolver.ResolvePotentialEntityComparison(sqlIsNullExpression);
Assert.That(result, Is.SameAs(sqlIsNullExpression));
}
public void SplitPotentialCompoundComparison_SqlIsNullExpression_ReturnsNonNewExpression_Unchanged()
{
var expression = Expression.Constant(1);
var sqlIsNullExpression = new SqlIsNullExpression(expression);
var result = _compoundExpressionComparisonSplitter.SplitPotentialCompoundComparison(sqlIsNullExpression);
Assert.That(result, Is.SameAs(sqlIsNullExpression));
}
public void ResolvePotentialEntityComparison_SqlIsNullExpression_ResolvesEntitiesToIdentity()
{
var sqlIsNullExpression = new SqlIsNullExpression(_entityExpression);
var result = _entityIdentityResolver.ResolvePotentialEntityComparison(sqlIsNullExpression);
var expected = new SqlIsNullExpression(_entityExpression.GetIdentityExpression());
SqlExpressionTreeComparer.CheckAreEqualTrees(expected, result);
}
public void VisitSqlIsNullExpression()
{
var expression = Expression.Constant("test");
var sqlIsNullExpression = new SqlIsNullExpression(expression);
SqlGeneratingExpressionVisitor.GenerateSql(
sqlIsNullExpression, _commandBuilder, _stageMock);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("(@1 IS NULL)"));
}
public void SplitPotentialCompoundComparison_SqlIsNullExpression_ExpandsNewExpression_ByCheckingAllArguments_ZeroArguments()
{
var newExpression = Expression.New(TypeForNewExpression.GetConstructor());
var sqlIsNullExpression = new SqlIsNullExpression(newExpression);
var result = _compoundExpressionComparisonSplitter.SplitPotentialCompoundComparison(sqlIsNullExpression);
var expected = Expression.Constant(false);
SqlExpressionTreeComparer.CheckAreEqualTrees(expected, result);
}
public virtual Expression VisitSqlIsNullExpression(SqlIsNullExpression expression)
{
ArgumentUtility.CheckNotNull("expression", expression);
_commandBuilder.Append("(");
VisitExpression(expression.Expression);
_commandBuilder.Append(" IS NULL");
_commandBuilder.Append(")");
return(expression);
}
public SqlIsNullExpression ResolvePotentialEntityComparison(SqlIsNullExpression isNullExpression)
{
var newExpression = ResolvePotentialEntity(isNullExpression.Expression);
if (newExpression != isNullExpression.Expression)
{
return(new SqlIsNullExpression(newExpression));
}
return(isNullExpression);
}
public Expression VisitSqlIsNull(SqlIsNullExpression expression)
{
ArgumentUtility.CheckNotNull("expression", expression);
var newExpression = ApplySingleValueContext(expression.Expression);
if (newExpression != expression.Expression)
{
return(new SqlIsNullExpression(newExpression));
}
return(expression);
}
public void SplitPotentialCompoundComparison_SqlIsNullExpression_ExpandsNewExpression_ByCheckingAllArguments_OnlyOneArgument()
{
var arg1 = Expression.Constant(1);
var newExpression = Expression.New(TypeForNewExpression.GetConstructor(typeof(int)), new[] { arg1 });
var sqlIsNullExpression = new SqlIsNullExpression(newExpression);
var result = _compoundExpressionComparisonSplitter.SplitPotentialCompoundComparison(sqlIsNullExpression);
var expected = new SqlIsNullExpression(arg1);
SqlExpressionTreeComparer.CheckAreEqualTrees(expected, result);
}
public Expression Transform(MethodCallExpression methodCallExpression)
{
ArgumentUtility.CheckNotNull("methodCallExpression", methodCallExpression);
MethodCallTransformerUtility.CheckArgumentCount(methodCallExpression, 1);
MethodCallTransformerUtility.CheckStaticMethod(methodCallExpression);
var isNullExpression = new SqlIsNullExpression(methodCallExpression.Arguments[0]);
var lenExpression = new SqlLengthExpression(methodCallExpression.Arguments[0]);
var lenIsZeroExpression = Expression.Equal(lenExpression, new SqlLiteralExpression(0));
return(Expression.OrElse(isNullExpression, lenIsZeroExpression));
}
public void Transform()
{
var method = typeof(string).GetMethod("IsNullOrEmpty", new[] { typeof(string) });
var objectExpression = Expression.Constant("Test");
var expression = Expression.Call(method, objectExpression);
var transformer = new IsNullOrEmptyMethodCallTransformer();
var result = transformer.Transform(expression);
var expectedIsNullExpression = new SqlIsNullExpression(objectExpression);
var expectedLenExpression = new SqlLengthExpression(objectExpression);
var expectedResult = Expression.OrElse(expectedIsNullExpression, Expression.Equal(expectedLenExpression, new SqlLiteralExpression(0)));
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public Expression VisitSqlIsNull(SqlIsNullExpression expression)
{
ArgumentUtility.CheckNotNull("expression", expression);
var baseVisitedExpression = (SqlIsNullExpression)VisitExtension(expression);
var expressionWithEntityComparisonResolved = _entityIdentityResolver.ResolvePotentialEntityComparison(baseVisitedExpression);
var result = _compoundComparisonSplitter.SplitPotentialCompoundComparison(expressionWithEntityComparisonResolved);
if (baseVisitedExpression != result)
{
return(Visit(result));
}
return(baseVisitedExpression);
}
public Expression SplitPotentialCompoundComparison(SqlIsNullExpression potentialCompoundComparison)
{
ArgumentUtility.CheckNotNull("potentialCompoundComparison", potentialCompoundComparison);
var innerExpressionAsNewExpression = potentialCompoundComparison.Expression as NewExpression;
if (innerExpressionAsNewExpression != null)
{
if (innerExpressionAsNewExpression.Arguments.Count == 0)
{
return(Expression.Constant(false));
}
return(innerExpressionAsNewExpression.Arguments
.Select(arg => (Expression) new SqlIsNullExpression(arg))
.Aggregate(Expression.AndAlso));
}
return(potentialCompoundComparison);
}
public void VisitSqlIsNullExpression()
{
var inner = Expression.Constant(0);
var isNullExpression = new SqlIsNullExpression(inner);
var fakeResolvedInner = new SqlLiteralExpression(1);
_resolverMock.Expect(mock => mock.ResolveConstantExpression(inner)).Return(fakeResolvedInner);
var fakeResolvedEntityComparison = new SqlIsNullExpression(Expression.Constant(2));
_entityIdentityResolverMock
.Expect(mock => mock.ResolvePotentialEntityComparison(Arg <SqlIsNullExpression> .Matches(e => e.Expression == fakeResolvedInner)))
.Return(fakeResolvedEntityComparison);
var fakeSplitCompoundComparison = new SqlIsNullExpression(Expression.Constant(3));
_compoundComparisonSplitterMock
.Expect(mock => mock.SplitPotentialCompoundComparison(fakeResolvedEntityComparison))
.Return(fakeSplitCompoundComparison);
// Result is revisited
_resolverMock
.Expect(mock => mock.ResolveConstantExpression((ConstantExpression)fakeSplitCompoundComparison.Expression))
.Return(fakeSplitCompoundComparison.Expression);
_entityIdentityResolverMock
.Expect(mock => mock.ResolvePotentialEntityComparison(fakeSplitCompoundComparison))
.Return(fakeSplitCompoundComparison);
_compoundComparisonSplitterMock
.Expect(mock => mock.SplitPotentialCompoundComparison(fakeSplitCompoundComparison))
.Return(fakeSplitCompoundComparison);
var result = _visitor.Visit(isNullExpression);
_resolverMock.VerifyAllExpectations();
_entityIdentityResolverMock.VerifyAllExpectations();
_compoundComparisonSplitterMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(fakeSplitCompoundComparison));
}
public void SetUp()
{
_sqlIsNullExpression = new SqlIsNullExpression(Expression.Constant(2));
}
