public void VisitSqlSubStatementExpression_ConvertsToSqlTable_ForStreamedSingleValueInfo()
{
var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement_Single();
var fakeResolvedSqlStatement = SqlStatementModelObjectMother.CreateSqlStatement_Single();
var expression = new SqlSubStatementExpression(sqlStatement);
var resolvedReference = Expression.Constant("fake");
SqlTable sqlTable = null;
_stageMock
.Expect(mock => mock.ResolveSqlStatement(sqlStatement, _mappingResolutionContext))
.Return(fakeResolvedSqlStatement);
_groupAggregateSimplifier
.Expect(
mock => mock.SimplifyIfPossible(
Arg <SqlSubStatementExpression> .Matches(e => e.SqlStatement == fakeResolvedSqlStatement), Arg.Is(sqlStatement.SelectProjection)))
.Return(null)
.WhenCalled(mi => mi.ReturnValue = mi.Arguments[0]);
_stageMock
.Expect(mock => mock.ResolveTableReferenceExpression(Arg <SqlTableReferenceExpression> .Is.Anything, Arg.Is(_mappingResolutionContext)))
.WhenCalled(
mi =>
{
var expectedStatement =
new SqlStatementBuilder(fakeResolvedSqlStatement)
{
DataInfo = new StreamedSequenceInfo(typeof(IEnumerable <int>), fakeResolvedSqlStatement.SelectProjection)
}.GetSqlStatement();
sqlTable = (SqlTable)((SqlTableReferenceExpression)mi.Arguments[0]).SqlTable;
Assert.That(((ResolvedSubStatementTableInfo)sqlTable.TableInfo).SqlStatement, Is.EqualTo(expectedStatement));
})
.Return(resolvedReference);
_resolverMock.Expect(mock => mock.ResolveConstantExpression(resolvedReference)).Return(resolvedReference);
var sqlStatementBuilder = new SqlStatementBuilder(sqlStatement);
var visitor = CreateVisitor(sqlStatementBuilder);
Assert.That(sqlStatementBuilder.SqlTables.Count, Is.EqualTo(0));
var result = visitor.VisitExpression(expression);
_stageMock.VerifyAllExpectations();
_groupAggregateSimplifier.VerifyAllExpectations();
_resolverMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(resolvedReference));
Assert.That(sqlStatementBuilder.SqlTables.Count, Is.EqualTo(1));
Assert.That(sqlStatementBuilder.SqlTables[0], Is.EqualTo(sqlTable));
}
public void HandleResultOperator_TransformSubqueriesUsedAsGroupByKeys()
{
var keySelector = Expression.Constant("keySelector");
var elementSelector = Expression.Constant("elementSelector");
var resultOperator = new GroupResultOperator("itemName", keySelector, elementSelector);
var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement_Single();
var preparedSubStatementKeySelector = new SqlSubStatementExpression(sqlStatement);
_stageMock
.Expect(mock => mock.PrepareResultOperatorItemExpression(keySelector, _context))
.Return(preparedSubStatementKeySelector);
_stageMock
.Expect(mock => mock.PrepareResultOperatorItemExpression(elementSelector, _context))
.Return(elementSelector);
_stageMock.Replay();
_handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, _generator, _stageMock, _context);
_stageMock.VerifyAllExpectations();
Assert.That(_sqlStatementBuilder.SqlTables.Count, Is.EqualTo(2));
Assert.That(_sqlStatementBuilder.SqlTables[1], Is.TypeOf(typeof(SqlTable)));
Assert.That(((SqlTable)_sqlStatementBuilder.SqlTables[1]).TableInfo, Is.TypeOf(typeof(ResolvedSubStatementTableInfo)));
var groupKeyTableTableInfo = (ResolvedSubStatementTableInfo)((SqlTable)_sqlStatementBuilder.SqlTables[1]).TableInfo;
var expectedStatement = new SqlStatementBuilder(sqlStatement)
{
DataInfo = new StreamedSequenceInfo(typeof(IEnumerable <int>), sqlStatement.SelectProjection)
}
.GetSqlStatement();
Assert.That(groupKeyTableTableInfo.SqlStatement, Is.EqualTo(expectedStatement));
var expectedGroupGyExpression = new SqlTableReferenceExpression(_sqlStatementBuilder.SqlTables[1]);
SqlExpressionTreeComparer.CheckAreEqualTrees(_sqlStatementBuilder.GroupByExpression, expectedGroupGyExpression);
SqlExpressionTreeComparer.CheckAreEqualTrees(
_sqlStatementBuilder.SelectProjection,
SqlGroupingSelectExpression.CreateWithNames(expectedGroupGyExpression, elementSelector));
}
public void ResolveSelectExpression_SqlSubStatementExpressionWithStreamedSingleValueInfo()
{
var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement_Single();
var expression = new SqlSubStatementExpression(sqlStatement);
var sqlStatementBuilder = new SqlStatementBuilder();
_resolverMock
.Expect(mock => mock.ResolveConstantExpression(((ConstantExpression)sqlStatement.SelectProjection)))
.Return(sqlStatement.SelectProjection);
_resolverMock.Replay();
var result = _stage.ResolveSelectExpression(expression, sqlStatementBuilder, _mappingResolutionContext);
_resolverMock.VerifyAllExpectations();
var expectedDataInfo = new StreamedSequenceInfo(typeof(IEnumerable <>).MakeGenericType(sqlStatement.DataInfo.DataType), sqlStatement.SelectProjection);
var expectedSqlStatement = new SqlStatementBuilder(sqlStatement)
{
DataInfo = expectedDataInfo
}.GetSqlStatement();
Assert.That(sqlStatementBuilder.SqlTables.Count, Is.EqualTo(1));
Assert.That(((ResolvedSubStatementTableInfo)((SqlTable)sqlStatementBuilder.SqlTables[0]).TableInfo).SqlStatement, Is.EqualTo(expectedSqlStatement));
Assert.That(result, Is.SameAs(sqlStatement.SelectProjection));
}
