public void VisitSqlInExpression_RevisitingTerminatesAfterInnerChanges_WithoutOuterChanges()
{
var left = Expression.Constant(0);
var right = Expression.Constant(1);
var inExpression = new SqlInExpression(left, right);
var fakeResolvedLeft = new SqlLiteralExpression(2);
_resolverMock.Expect(mock => mock.ResolveConstantExpression(left)).Return(fakeResolvedLeft);
var fakeResolvedRight = new SqlLiteralExpression(3);
_resolverMock.Expect(mock => mock.ResolveConstantExpression(right)).Return(fakeResolvedRight);
_entityIdentityResolverMock
.Expect(mock => mock.ResolvePotentialEntityComparison(Arg <SqlInExpression> .Is.Anything))
.Return(null)
.WhenCalled(mi => mi.ReturnValue = mi.Arguments[0]);
// No revisiting
var result = _visitor.Visit(inExpression);
_resolverMock.VerifyAllExpectations();
_entityIdentityResolverMock.VerifyAllExpectations();
Assert.That(result, Is.TypeOf <SqlInExpression> ());
Assert.That(((SqlInExpression)result).LeftExpression, Is.SameAs(fakeResolvedLeft));
Assert.That(((SqlInExpression)result).RightExpression, Is.SameAs(fakeResolvedRight));
}
public void SetUp()
{
_leftExpression = Expression.Constant(1);
_rightExpression = Expression.Constant(2);
_expression = new SqlInExpression(_leftExpression, _rightExpression);
}
public void ResolvePotentialEntityComparison_SqlInExpression_NonEntities_ReturnsSameExpression()
{
var sqlInExpression = new SqlInExpression(Expression.Constant(0), Expression.Constant(0));
var result = _entityIdentityResolver.ResolvePotentialEntityComparison(sqlInExpression);
Assert.That(result, Is.SameAs(sqlInExpression));
}
public void ResolvePotentialEntityComparison_SqlInExpression_EntitiesAreResolvedToIdentity_RightOnly()
{
var sqlInExpression = new SqlInExpression(Expression.Constant(null, typeof(Cook)), _entityExpression);
var result = _entityIdentityResolver.ResolvePotentialEntityComparison(sqlInExpression);
var expected = new SqlInExpression(Expression.Constant(null, typeof(Cook)), _entityExpression.GetIdentityExpression());
SqlExpressionTreeComparer.CheckAreEqualTrees(expected, result);
}
public void ResolvePotentialEntityComparison_SqlInExpression_ResolvesEntitiesToIdentity()
{
var sqlInExpression = new SqlInExpression(_entityExpression, _entityConstantExpression);
var result = _entityIdentityResolver.ResolvePotentialEntityComparison(sqlInExpression);
var expected = new SqlInExpression(_entityExpression.GetIdentityExpression(), _entityConstantExpression.IdentityExpression);
SqlExpressionTreeComparer.CheckAreEqualTrees(expected, result);
}
public virtual Expression VisitSqlInExpression(SqlInExpression expression)
{
ArgumentUtility.CheckNotNull("expression", expression);
VisitExpression(expression.LeftExpression);
_commandBuilder.Append(" IN ");
VisitExpression(expression.RightExpression);
return(expression);
}
public void ResolveTypeCheck_ExpressionTypeIsAssignableFromDesiredType_WithSingleClassID()
{
var sqlEntityExpression = (SqlEntityExpression)CreateFakeEntityExpression(typeof(Company));
var result = _resolver.ResolveTypeCheck(sqlEntityExpression, typeof(Distributor));
var idExpression = Expression.MakeMemberAccess(sqlEntityExpression, typeof(DomainObject).GetProperty("ID"));
var classIDExpression = Expression.MakeMemberAccess(idExpression, typeof(ObjectID).GetProperty("ClassID"));
var expectedExpression = new SqlInExpression(
classIDExpression, new SqlCollectionExpression(typeof(string[]), new Expression[] { new SqlLiteralExpression("Distributor") }));
SqlExpressionTreeComparer.CheckAreEqualTrees(result, expectedExpression);
}
public void ResolveTypeCheck_NoQueryableTable()
{
var sqlEntityExpression = (SqlEntityExpression)CreateFakeEntityExpression(typeof(AboveInheritanceRootClass));
var result = _resolver.ResolveTypeCheck(sqlEntityExpression, typeof(StorageGroupClass));
var idExpression = Expression.MakeMemberAccess(sqlEntityExpression, typeof(DomainObject).GetProperty("ID"));
var classIDExpression = Expression.MakeMemberAccess(idExpression, typeof(ObjectID).GetProperty("ClassID"));
var expectedExpression = new SqlInExpression(
classIDExpression, new SqlCollectionExpression(typeof(string[]), new Expression[] { new SqlLiteralExpression("StorageGroupClass") }));
SqlExpressionTreeComparer.CheckAreEqualTrees(result, expectedExpression);
}
public Expression VisitSqlInExpression(SqlInExpression expression)
{
var baseVisitedExpression = (SqlInExpression)VisitExtensionExpression(expression);
var expressionWithSimplifiedEntities = _entityIdentityResolver.ResolvePotentialEntityComparison(baseVisitedExpression);
if (expressionWithSimplifiedEntities != baseVisitedExpression)
{
return(VisitExpression(expressionWithSimplifiedEntities));
}
return(baseVisitedExpression);
}
public SqlInExpression ResolvePotentialEntityComparison(SqlInExpression inExpression)
{
ArgumentUtility.CheckNotNull("inExpression", inExpression);
var newLeft = ResolvePotentialEntity(inExpression.LeftExpression);
var newRight = ResolvePotentialEntity(inExpression.RightExpression);
if (newLeft != inExpression.LeftExpression || newRight != inExpression.RightExpression)
{
return(new SqlInExpression(newLeft, newRight));
}
return(inExpression);
}
protected virtual string VisitIn(SqlInExpression expr)
{
string result;
if (expr.Not)
{
result = $"{Visit(expr.Expression)} NOT IN ({EmitParameter(expr.Range)})";
}
else
{
result = $"{Visit(expr.Expression)} IN ({EmitParameter(expr.Range)})";
}
return(result.Braces(!expr.IsTop));
}
public Expression VisitSqlIn(SqlInExpression expression)
{
try
{
return(VisitChildrenWithGivenSemantics(expression, SqlExpressionContext.SingleValueRequired));
}
catch (NotSupportedException ex)
{
var message = string.Format(
"The SQL 'IN' operator (originally probably a call to a 'Contains' method) requires a single value, so the following expression cannot "
+ "be translated to SQL: '{0}'.",
expression);
throw new NotSupportedException(message, ex);
}
}
public Expression VisitSqlIn(SqlInExpression expression)
{
ArgumentUtility.CheckNotNull("expression", expression);
var baseVisitedExpression = (SqlInExpression)VisitExtension(expression);
var expressionWithSimplifiedEntities = _entityIdentityResolver.ResolvePotentialEntityComparison(baseVisitedExpression);
if (expressionWithSimplifiedEntities != baseVisitedExpression)
{
return(Visit(expressionWithSimplifiedEntities));
}
return(baseVisitedExpression);
}
public void VisitSqlInExpression()
{
var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatementWithCook();
var sqlSubStatementExpression = new SqlSubStatementExpression(sqlStatement);
var sqlInExpression = new SqlInExpression(Expression.Constant(1), sqlSubStatementExpression);
_stageMock
.Expect(
mock =>
mock.GenerateTextForSqlStatement(
Arg.Is(_commandBuilder), Arg <SqlStatement> .Is.Anything))
.WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("test"));
_stageMock.Replay();
SqlGeneratingExpressionVisitor.GenerateSql(
sqlInExpression, _commandBuilder, _stageMock);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("@1 IN (test)"));
_stageMock.VerifyAllExpectations();
}
public void HandleResultOperator()
{
var itemExpression = Expression.Constant(new Cook());
var resultOperator = new ContainsResultOperator(itemExpression);
var sqlStatement = _sqlStatementBuilder.GetSqlStatement();
var preparedExpression = Expression.Constant(new Cook(), typeof(Cook));
_stageMock.Expect(mock => mock.PrepareResultOperatorItemExpression(itemExpression, _context)).Return(preparedExpression);
_stageMock.Replay();
_handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, _generator, _stageMock, _context);
_stageMock.VerifyAllExpectations();
Assert.That(_sqlStatementBuilder.DataInfo, Is.TypeOf(typeof(StreamedScalarValueInfo)));
Assert.That(((StreamedScalarValueInfo)_sqlStatementBuilder.DataInfo).DataType, Is.EqualTo(typeof(Boolean)));
var expectedExpression = new SqlInExpression(preparedExpression, new SqlSubStatementExpression(sqlStatement));
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedExpression, _sqlStatementBuilder.SelectProjection);
}
public void VisitSqlInExpression()
{
var left = Expression.Constant(0);
var right = Expression.Constant(1);
var inExpression = new SqlInExpression(left, right);
var fakeResolvedLeft = new SqlLiteralExpression(2);
_resolverMock.Expect(mock => mock.ResolveConstantExpression(left)).Return(fakeResolvedLeft);
var fakeResolvedRight = new SqlLiteralExpression(3);
_resolverMock.Expect(mock => mock.ResolveConstantExpression(right)).Return(fakeResolvedRight);
var fakeResolvedInExpression = new SqlInExpression(Expression.Constant(4), Expression.Constant(5));
_entityIdentityResolverMock
.Expect(
mock => mock.ResolvePotentialEntityComparison(
Arg <SqlInExpression> .Matches(e => e.LeftExpression == fakeResolvedLeft && e.RightExpression == fakeResolvedRight)))
.Return(fakeResolvedInExpression);
// Result is revisited
_resolverMock
.Expect(mock => mock.ResolveConstantExpression((ConstantExpression)fakeResolvedInExpression.LeftExpression))
.Return(fakeResolvedInExpression.LeftExpression);
_resolverMock
.Expect(mock => mock.ResolveConstantExpression((ConstantExpression)fakeResolvedInExpression.RightExpression))
.Return(fakeResolvedInExpression.RightExpression);
_entityIdentityResolverMock
.Expect(mock => mock.ResolvePotentialEntityComparison(fakeResolvedInExpression))
.Return(fakeResolvedInExpression);
var result = _visitor.Visit(inExpression);
_resolverMock.VerifyAllExpectations();
_entityIdentityResolverMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(fakeResolvedInExpression));
}
