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)); }