public void EnsureNoSetOperations_WithSetOperations() { _statementBuilder.SetOperationCombinedStatements.Add(SqlStatementModelObjectMother.CreateSetOperationCombinedStatement()); var originalStatement = _statementBuilder.GetSqlStatement(); var fakeFromExpressionInfo = CreateFakeFromExpressionInfo(new Ordering[0]); _stageMock .Expect( mock => mock.PrepareFromExpression( Arg <Expression> .Is.Anything, Arg <ISqlPreparationContext> .Is.Anything, Arg <Func <ITableInfo, SqlTable> > .Is.Anything, Arg.Is(OrderingExtractionPolicy.ExtractOrderingsIntoProjection))) .Return(fakeFromExpressionInfo); _stageMock.Replay(); _handler.EnsureNoSetOperations(_statementBuilder, _generator, _stageMock, _context); _stageMock.VerifyAllExpectations(); Assert.That(_statementBuilder.GetSqlStatement(), Is.Not.EqualTo(originalStatement)); Assert.That(_statementBuilder.SetOperationCombinedStatements, Is.Empty); var sqlTable = _statementBuilder.SqlTables[0]; Assert.That(((ResolvedSubStatementTableInfo)sqlTable.TableInfo).SqlStatement, Is.EqualTo(originalStatement)); Assert.That(sqlTable.JoinSemantics, Is.EqualTo(JoinSemantics.Inner)); }
public void Build_WithSetOperationCombinedStatement() { var setOperationCombinedStatement = SqlStatementModelObjectMother.CreateSetOperationCombinedStatement(); var sqlStatement = SqlStatementModelObjectMother.CreateMinimalSqlStatement(new SqlStatementBuilder { SqlTables = { _sqlTable }, SetOperationCombinedStatements = { setOperationCombinedStatement } }); _stageMock.Expect( mock => mock.GenerateTextForSelectExpression(_commandBuilder, sqlStatement.SelectProjection)) .WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("[t].[ID],[t].[Name],[t].[City]")); _stageMock.Expect(mock => mock.GenerateTextForFromTable(_commandBuilder, sqlStatement.SqlTables[0], true)) .WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("[Table] AS [t]")); _stageMock.Expect(mock => mock.GenerateTextForSqlStatement(_commandBuilder, sqlStatement.SetOperationCombinedStatements[0].SqlStatement)) .WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("SELECT FOO FROM BAR")); _stageMock.Replay(); _generator.Build(sqlStatement, _commandBuilder, false); _commandBuilder.SetInMemoryProjectionBody(Expression.Constant(0)); var result = _commandBuilder.GetCommand(); Assert.That(result.CommandText, Is.EqualTo("SELECT [t].[ID],[t].[Name],[t].[City] FROM [Table] AS [t] UNION (SELECT FOO FROM BAR)")); _stageMock.VerifyAllExpectations(); }
public void HandleResultOperator_AfterSetOperation_CreatesSubStatement() { _sqlStatementBuilder.SetOperationCombinedStatements.Add(SqlStatementModelObjectMother.CreateSetOperationCombinedStatement()); var resultOperator = new MaxResultOperator(); _handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, UniqueIdentifierGenerator, _stage, _context); AssertStatementWasMovedToSubStatement(_sqlStatementBuilder); }
public void HandleResultOperator_TakeAfterSetOperation() { _sqlStatementBuilder.SetOperationCombinedStatements.Add(SqlStatementModelObjectMother.CreateSetOperationCombinedStatement()); var takeExpression = Expression.Constant(2); var resultOperator = new TakeResultOperator(takeExpression); _handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, UniqueIdentifierGenerator, _stage, _context); AssertStatementWasMovedToSubStatement(_sqlStatementBuilder); }
public void HandleResultOperator_SkipAfterSetOperations_MovesStatementToSubStatement() { _sqlStatementBuilder.SetOperationCombinedStatements.Add(SqlStatementModelObjectMother.CreateSetOperationCombinedStatement()); var resultOperator = new SkipResultOperator(Expression.Constant(0)); var stage = CreateDefaultSqlPreparationStage(); _handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, UniqueIdentifierGenerator, stage, _context); AssertStatementWasMovedToSubStatement(GetSubStatement(_sqlStatementBuilder.SqlTables[0])); }
public void ResolveSqlStatement_WithNoChanges_ShouldLeaveAllObjectsTheSame() { var constantExpression = Expression.Constant(new Restaurant()); var whereCondition = Expression.Constant(true); var topExpression = Expression.Constant("top"); var groupExpression = Expression.Constant("group"); var ordering = new Ordering(Expression.Constant("ordering"), OrderingDirection.Desc); var setOperationCombinedStatement = SqlStatementModelObjectMother.CreateSetOperationCombinedStatement(); var builder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook))) { SelectProjection = constantExpression, DataInfo = new StreamedSequenceInfo(typeof(Restaurant[]), constantExpression), WhereCondition = whereCondition, GroupByExpression = groupExpression, TopExpression = topExpression, SetOperationCombinedStatements = { setOperationCombinedStatement } }; builder.Orderings.Add(ordering); var sqlStatement = builder.GetSqlStatement(); _stageMock .Expect(mock => mock.ResolveSelectExpression(Arg.Is(constantExpression), Arg <SqlStatementBuilder> .Is.Anything, Arg.Is(_mappingResolutionContext))) .Return(constantExpression); _stageMock .Expect(mock => mock.ResolveWhereExpression(whereCondition, _mappingResolutionContext)) .Return(whereCondition); _stageMock .Expect(mock => mock.ResolveGroupByExpression(groupExpression, _mappingResolutionContext)) .Return(groupExpression); _stageMock .Expect(mock => mock.ResolveTopExpression(topExpression, _mappingResolutionContext)) .Return(topExpression); _stageMock .Expect(mock => mock.ResolveOrderingExpression(ordering.Expression, _mappingResolutionContext)) .Return(ordering.Expression); _stageMock .Expect(mock => mock.ResolveTableInfo(sqlStatement.SqlTables[0].TableInfo, _mappingResolutionContext)) .Return((IResolvedTableInfo)sqlStatement.SqlTables[0].TableInfo); _stageMock .Expect(mock => mock.ResolveSqlStatement(setOperationCombinedStatement.SqlStatement, _mappingResolutionContext)) .Return(setOperationCombinedStatement.SqlStatement); _stageMock.Replay(); var resolvedSqlStatement = _visitor.ResolveSqlStatement(sqlStatement); _stageMock.VerifyAllExpectations(); Assert.That(resolvedSqlStatement, Is.EqualTo(sqlStatement)); }
public void HandleResultOperator_GroupByAfterSetOperations() { _sqlStatementBuilder.SetOperationCombinedStatements.Add(SqlStatementModelObjectMother.CreateSetOperationCombinedStatement()); var keySelector = new SqlColumnDefinitionExpression(typeof(string), "c", "Name", false); var elementSelector = Expression.Constant("elementSelector"); var resultOperator = new GroupResultOperator("itemName", keySelector, elementSelector); var stage = CreateDefaultSqlPreparationStage(); _handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, UniqueIdentifierGenerator, stage, _context); AssertStatementWasMovedToSubStatement(_sqlStatementBuilder); }
public void HandleResultOperator_AllAfterSetOperation() { _sqlStatementBuilder.SetOperationCombinedStatements.Add(SqlStatementModelObjectMother.CreateSetOperationCombinedStatement()); var stage = CreateDefaultSqlPreparationStage(); var predicate = Expression.Constant(true); var resultOperator = new AllResultOperator(predicate); _handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, UniqueIdentifierGenerator, stage, _context); var innerStatementOfExistsExpression = GetInnerStatementAfterExistsTransformation(_sqlStatementBuilder); AssertStatementWasMovedToSubStatement(innerStatementOfExistsExpression); }
public void BuildSelectPart_OuterSelect_WithSetOperationsAggregation() { var sqlStatement = SqlStatementModelObjectMother.CreateMinimalSqlStatement(new SqlStatementBuilder { SetOperationCombinedStatements = { SqlStatementModelObjectMother.CreateSetOperationCombinedStatement() } }); _stageMock.Expect( mock => mock.GenerateTextForOuterSelectExpression( _commandBuilder, sqlStatement.SelectProjection, SetOperationsMode.StatementIsSetCombined) ); _generator.BuildSelectPart(sqlStatement, _commandBuilder, true); _stageMock.VerifyAllExpectations(); }
public void ResolveSqlStatement() { var constantExpression = Expression.Constant(new Restaurant()); var whereCondition = Expression.Constant(true); var topExpression = Expression.Constant("top"); var groupExpression = Expression.Constant("group"); var ordering = new Ordering(Expression.Constant("ordering"), OrderingDirection.Desc); var setOperationCombinedStatement = SqlStatementModelObjectMother.CreateSetOperationCombinedStatement(); var builder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook))) { SelectProjection = constantExpression, DataInfo = new StreamedSequenceInfo(typeof(Restaurant[]), constantExpression), WhereCondition = whereCondition, GroupByExpression = groupExpression, TopExpression = topExpression, SetOperationCombinedStatements = { setOperationCombinedStatement } }; builder.Orderings.Add(ordering); var sqlStatement = builder.GetSqlStatement(); var fakeExpression = Expression.Constant(new Cook()); var fakeWhereCondition = Expression.Constant(true); var fakeGroupExpression = Expression.Constant("group"); var fakeTopExpression = Expression.Constant("top"); var fakeOrderExpression = Expression.Constant("order"); var fakeSqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(); Assert.That(fakeSqlStatement, Is.Not.EqualTo(setOperationCombinedStatement.SqlStatement), "This is important for the test below."); _stageMock .Expect(mock => mock.ResolveSelectExpression(Arg.Is(constantExpression), Arg <SqlStatementBuilder> .Is.Anything, Arg.Is(_mappingResolutionContext))) .Return(fakeExpression); _stageMock .Expect(mock => mock.ResolveWhereExpression(whereCondition, _mappingResolutionContext)) .Return(fakeWhereCondition); _stageMock .Expect(mock => mock.ResolveGroupByExpression(groupExpression, _mappingResolutionContext)) .Return(fakeGroupExpression); _stageMock .Expect(mock => mock.ResolveTopExpression(topExpression, _mappingResolutionContext)) .Return(fakeTopExpression); _stageMock .Expect(mock => mock.ResolveOrderingExpression(ordering.Expression, _mappingResolutionContext)) .Return(fakeOrderExpression); _stageMock .Expect(mock => mock.ResolveTableInfo(sqlStatement.SqlTables[0].TableInfo, _mappingResolutionContext)) .Return(new ResolvedSimpleTableInfo(typeof(Cook), "CookTable", "c")); _stageMock .Expect(mock => mock.ResolveSqlStatement(setOperationCombinedStatement.SqlStatement, _mappingResolutionContext)) .Return(fakeSqlStatement); _stageMock.Replay(); var resolvedSqlStatement = _visitor.ResolveSqlStatement(sqlStatement); _stageMock.VerifyAllExpectations(); Assert.That(resolvedSqlStatement.DataInfo, Is.TypeOf(typeof(StreamedSequenceInfo))); Assert.That(((StreamedSequenceInfo)resolvedSqlStatement.DataInfo).DataType, Is.EqualTo(typeof(IQueryable <>).MakeGenericType(typeof(Cook)))); Assert.That(resolvedSqlStatement.SelectProjection, Is.SameAs(fakeExpression)); Assert.That(resolvedSqlStatement.WhereCondition, Is.SameAs(fakeWhereCondition)); Assert.That(resolvedSqlStatement.TopExpression, Is.SameAs(fakeTopExpression)); Assert.That(resolvedSqlStatement.GroupByExpression, Is.SameAs(fakeGroupExpression)); Assert.That(resolvedSqlStatement.Orderings[0].Expression, Is.SameAs(fakeOrderExpression)); Assert.That(sqlStatement.Orderings[0].Expression, Is.SameAs(ordering.Expression)); Assert.That(resolvedSqlStatement.SetOperationCombinedStatements.Single().SqlStatement, Is.SameAs(fakeSqlStatement)); }