public void HandleResultOperator()
{
var resultOperator = new AnyResultOperator();
var sqlStatement = _sqlStatementBuilder.GetSqlStatement();
var fakePreparedSelectProjection = Expression.Constant(false);
_stageMock
.Expect(mock => mock.PrepareSelectExpression(Arg <Expression> .Matches(e => e is SqlExistsExpression), Arg.Is(_context)))
.WhenCalled(
mi =>
{
var selectProjection = (Expression)mi.Arguments[0];
Assert.That(selectProjection, Is.TypeOf(typeof(SqlExistsExpression)));
var expectedExistsExpression = new SqlExistsExpression(new SqlSubStatementExpression(sqlStatement));
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedExistsExpression, selectProjection);
})
.Return(fakePreparedSelectProjection);
_handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, _generator, _stageMock, _context);
Assert.That(_sqlStatementBuilder.DataInfo, Is.TypeOf(typeof(StreamedScalarValueInfo)));
Assert.That(((StreamedScalarValueInfo)_sqlStatementBuilder.DataInfo).DataType, Is.EqualTo(typeof(Boolean)));
_stageMock.VerifyAllExpectations();
Assert.That(_sqlStatementBuilder.SelectProjection, Is.SameAs(fakePreparedSelectProjection));
}
public void VisitSqlExistsExpression()
{
var inner = Expression.Constant(0);
var existsExpression = new SqlExistsExpression(inner);
var fakeResolvedInner = new SqlLiteralExpression(1);
_resolverMock.Expect(mock => mock.ResolveConstantExpression(inner)).Return(fakeResolvedInner);
var fakeResolvedEntityIdentity = Expression.Constant(1);
_entityIdentityResolverMock
.Expect(mock => mock.ResolvePotentialEntity(fakeResolvedInner))
.Return(fakeResolvedEntityIdentity);
// Result is revisited
_resolverMock.Expect(mock => mock.ResolveConstantExpression(fakeResolvedEntityIdentity)).Return(fakeResolvedEntityIdentity);
_entityIdentityResolverMock.Expect(mock => mock.ResolvePotentialEntity(fakeResolvedEntityIdentity)).Return(fakeResolvedEntityIdentity);
var result = _visitor.Visit(existsExpression);
_resolverMock.VerifyAllExpectations();
_entityIdentityResolverMock.VerifyAllExpectations();
Assert.That(result, Is.TypeOf <SqlExistsExpression>());
Assert.That(((SqlExistsExpression)result).Expression, Is.SameAs(fakeResolvedEntityIdentity));
}
public void VisitExistsExpression()
{
var expression = new SqlExistsExpression(Expression.Constant("test"));
SqlGeneratingExpressionVisitor.GenerateSql(expression, _commandBuilder, _stageMock);
var result = _commandBuilder.GetCommandText();
Assert.That(result, Is.EqualTo("EXISTS(@1)"));
}
public virtual Expression VisitSqlExistsExpression(SqlExistsExpression expression)
{
ArgumentUtility.CheckNotNull("expression", expression);
_commandBuilder.Append("EXISTS");
_commandBuilder.Append("(");
VisitExpression(expression.Expression);
_commandBuilder.Append(")");
return(expression);
}
public Expression VisitSqlExistsExpression(SqlExistsExpression expression)
{
var baseVisitedExpression = (SqlExistsExpression)VisitExtensionExpression(expression);
// Within an EXISTS query, an entity can be replaced by its IdentityExpression, so try to simplify it.
var newInnerExpression = _entityIdentityResolver.ResolvePotentialEntity(baseVisitedExpression.Expression);
if (newInnerExpression != baseVisitedExpression.Expression)
{
return(VisitExpression(new SqlExistsExpression(newInnerExpression)));
}
return(baseVisitedExpression);
}
public override void HandleResultOperator(AnyResultOperator resultOperator, SqlStatementBuilder sqlStatementBuilder, UniqueIdentifierGenerator generator, ISqlPreparationStage stage, ISqlPreparationContext context)
{
ArgumentUtility.CheckNotNull("resultOperator", resultOperator);
ArgumentUtility.CheckNotNull("sqlStatementBuilder", sqlStatementBuilder);
ArgumentUtility.CheckNotNull("generator", generator);
ArgumentUtility.CheckNotNull("stage", stage);
ArgumentUtility.CheckNotNull("context", context);
// No name required for the select projection inside of an EXISTS expression
var sqlSubStatement = sqlStatementBuilder.GetStatementAndResetBuilder();
var subStatementExpression = new SqlSubStatementExpression(sqlSubStatement);
var sqlExistsExpression = new SqlExistsExpression(subStatementExpression);
sqlStatementBuilder.SelectProjection = stage.PrepareSelectExpression(sqlExistsExpression, context);
UpdateDataInfo(resultOperator, sqlStatementBuilder, sqlSubStatement.DataInfo);
}
public void HandleResultOperator()
{
var predicate = Expression.Constant(true);
var preparedPredicate = Expression.Constant(false);
var resultOperator = new AllResultOperator(predicate);
var sqlStatement = _sqlStatementBuilder.GetSqlStatement();
var fakePreparedSelectProjection = Expression.Constant(false);
_stageMock
.Expect(mock => mock.PrepareWhereExpression(
Arg <Expression> .Matches(e => e.NodeType == ExpressionType.Not && (((UnaryExpression)e).Operand == predicate)),
Arg <ISqlPreparationContext> .Matches(c => c == _context)))
.Return(preparedPredicate);
_stageMock
.Expect(mock => mock.PrepareSelectExpression(Arg <Expression> .Matches(e => e.NodeType == ExpressionType.Not), Arg.Is(_context)))
.WhenCalled(
mi =>
{
var selectProjection = (Expression)mi.Arguments[0];
var expectedSubStatement = new SqlStatementBuilder(sqlStatement)
{
WhereCondition = preparedPredicate
}.GetSqlStatement();
var expectedExistsExpression = new SqlExistsExpression(new SqlSubStatementExpression(expectedSubStatement));
var expectedExpression = Expression.Not(expectedExistsExpression);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedExpression, selectProjection);
})
.Return(fakePreparedSelectProjection);
_stageMock.Replay();
_handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, UniqueIdentifierGenerator, _stageMock, _context);
_stageMock.VerifyAllExpectations();
Assert.That(_sqlStatementBuilder.DataInfo, Is.TypeOf(typeof(StreamedScalarValueInfo)));
Assert.That(((StreamedScalarValueInfo)_sqlStatementBuilder.DataInfo).DataType, Is.EqualTo(typeof(Boolean)));
Assert.That(_sqlStatementBuilder.SelectProjection, Is.SameAs(fakePreparedSelectProjection));
}
public void VisitSqlExistsExpression_RevisitingTerminatesAfterInnerChanges_WithoutOuterChanges()
{
var inner = Expression.Constant(0);
var existsExpression = new SqlExistsExpression(inner);
var fakeResolvedInner = new SqlLiteralExpression(1);
_resolverMock.Expect(mock => mock.ResolveConstantExpression(inner)).Return(fakeResolvedInner);
_entityIdentityResolverMock
.Expect(mock => mock.ResolvePotentialEntity(fakeResolvedInner))
.Return(fakeResolvedInner);
// No revisiting!
var result = _visitor.Visit(existsExpression);
_resolverMock.VerifyAllExpectations();
_entityIdentityResolverMock.VerifyAllExpectations();
Assert.That(result, Is.TypeOf <SqlExistsExpression> ());
Assert.That(((SqlExistsExpression)result).Expression, Is.SameAs(fakeResolvedInner));
}
public Expression VisitSqlExists(SqlExistsExpression expression)
{
return(VisitChildrenWithGivenSemantics(expression, SqlExpressionContext.ValueRequired));
}
public void SetUp()
{
_sqlExistsExpression = new SqlExistsExpression(Expression.Constant("test"));
}
