public void BuildOrderBy_WithMultipleOrderByClauses() { var columnExpression1 = new SqlColumnDefinitionExpression(typeof(string), "t", "ID", false); var orderByClause1 = new Ordering(columnExpression1, OrderingDirection.Asc); var columnExpression2 = new SqlColumnDefinitionExpression(typeof(string), "t", "Name", false); var orderByClause2 = new Ordering(columnExpression2, OrderingDirection.Desc); var columnExpression3 = new SqlColumnDefinitionExpression(typeof(string), "t", "City", false); var orderByClause3 = new Ordering(columnExpression3, OrderingDirection.Desc); var sqlStatement = SqlStatementModelObjectMother.CreateMinimalSqlStatement(new SqlStatementBuilder { Orderings = { orderByClause1, orderByClause2, orderByClause3 } }); _stageMock.Expect(mock => mock.GenerateTextForOrdering(_commandBuilder, sqlStatement.Orderings[0])) .WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("[t].[ID] ASC")); _stageMock.Expect(mock => mock.GenerateTextForOrdering(_commandBuilder, sqlStatement.Orderings[1])) .WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("[t].[Name] DESC")); _stageMock.Expect(mock => mock.GenerateTextForOrdering(_commandBuilder, sqlStatement.Orderings[2])) .WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("[t].[City] DESC")); _stageMock.Replay(); _generator.BuildOrderByPart(sqlStatement, _commandBuilder); Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo(" ORDER BY [t].[ID] ASC, [t].[Name] DESC, [t].[City] DESC")); _stageMock.VerifyAllExpectations(); }
public void Build_WithOrderByClause() { var columnExpression = new SqlColumnDefinitionExpression(typeof(string), "t", "Name", false); var ordering = new Ordering(columnExpression, OrderingDirection.Asc); var sqlStatement = SqlStatementModelObjectMother.CreateMinimalSqlStatement(new SqlStatementBuilder { SqlTables = { _sqlTable }, Orderings = { ordering } }); _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.GenerateTextForOrdering(_commandBuilder, sqlStatement.Orderings[0])) .WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("[t].[Name] ASC")); _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] ORDER BY [t].[Name] ASC")); _stageMock.VerifyAllExpectations(); }
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 Build_WithGroupByExpression() { var sqlGroupExpression = SqlStatementModelObjectMother.CreateSqlGroupingSelectExpression(); sqlGroupExpression.AddAggregationExpressionWithName(Expression.Constant("aggregation1")); sqlGroupExpression.AddAggregationExpressionWithName(Expression.Constant("aggregation2")); var sqlStatement = SqlStatementModelObjectMother.CreateMinimalSqlStatement(new SqlStatementBuilder { SqlTables = { _sqlTable }, GroupByExpression = sqlGroupExpression }); _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.GenerateTextForGroupByExpression(_commandBuilder, sqlStatement.GroupByExpression)) .WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("keyExpression")); _stageMock.Replay(); _generator.Build(sqlStatement, _commandBuilder, false); _stageMock.VerifyAllExpectations(); Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("SELECT [t].[ID],[t].[Name],[t].[City] FROM [Table] AS [t] GROUP BY keyExpression")); }
public void BuildDistinctPart() { var sqlStatement = SqlStatementModelObjectMother.CreateMinimalSqlStatement(new SqlStatementBuilder { IsDistinctQuery = true }); _generator.BuildDistinctPart(sqlStatement, _commandBuilder); Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("DISTINCT ")); _stageMock.VerifyAllExpectations(); }
public void Build_WithSelectAndNoFrom() { var sqlStatement = SqlStatementModelObjectMother.CreateMinimalSqlStatement(new SqlStatementBuilder()); _stageMock.Expect( mock => mock.GenerateTextForSelectExpression(_commandBuilder, sqlStatement.SelectProjection)) .WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("[t].[ID],[t].[Name],[t].[City]")); _stageMock.Replay(); _generator.Build(sqlStatement, _commandBuilder, false); Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("SELECT [t].[ID],[t].[Name],[t].[City]")); _stageMock.VerifyAllExpectations(); }
public void BuildWhere_WithSingleWhereCondition() { var sqlStatement = SqlStatementModelObjectMother.CreateMinimalSqlStatement(new SqlStatementBuilder { WhereCondition = Expression.Constant(true) }); _stageMock.Expect(mock => mock.GenerateTextForWhereExpression(_commandBuilder, sqlStatement.WhereCondition)) .WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("(@1 = 1)")); _stageMock.Replay(); _generator.BuildWherePart(sqlStatement, _commandBuilder); Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo(" WHERE (@1 = 1)")); _stageMock.VerifyAllExpectations(); }
public void HandleResultOperator_OrderingsWithTopInSource2_CausesMainStatementToBeMovedToSubStatement() { var sqlStatement = SqlStatementModelObjectMother.CreateMinimalSqlStatement(new SqlStatementBuilder { Orderings = { SqlStatementModelObjectMother.CreateOrdering() }, TopExpression = Expression.Constant(10) }); var resultOperator = new UnionResultOperator("x", typeof(int), new SqlSubStatementExpression(sqlStatement)); var stage = CreateDefaultSqlPreparationStage(); _handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, UniqueIdentifierGenerator, stage, _context); AssertStatementWasMovedToSubStatement(_sqlStatementBuilder); }
public void BuildFromPart_WithFrom() { var sqlStatement = SqlStatementModelObjectMother.CreateMinimalSqlStatement(new SqlStatementBuilder { SqlTables = { _sqlTable } }); _stageMock.Expect(mock => mock.GenerateTextForFromTable(_commandBuilder, sqlStatement.SqlTables[0], true)) .WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("[Table] AS [t]")); _stageMock.Replay(); _generator.BuildFromPart(sqlStatement, _commandBuilder); Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo(" FROM [Table] AS [t]")); _stageMock.VerifyAllExpectations(); }
public void BuildSelectPart_WithAggregation() { var aggregationExpression = new AggregationExpression(typeof(int), ExpressionHelper.CreateExpression(), AggregationModifier.Count); var sqlStatement = SqlStatementModelObjectMother.CreateMinimalSqlStatement(new SqlStatementBuilder { SelectProjection = aggregationExpression }); _stageMock.Expect( mock => mock.GenerateTextForSelectExpression(_commandBuilder, aggregationExpression)) .WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("COUNT(*)")); _generator.BuildSelectPart(sqlStatement, _commandBuilder, false); Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("SELECT COUNT(*)")); _stageMock.VerifyAllExpectations(); }
public void BuildTopPart() { var topExpression = Expression.Constant("top"); var sqlStatement = SqlStatementModelObjectMother.CreateMinimalSqlStatement(new SqlStatementBuilder { TopExpression = topExpression }); _stageMock.Expect(mock => mock.GenerateTextForTopExpression(_commandBuilder, topExpression)) .WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("top")); _stageMock.Replay(); _generator.BuildTopPart(sqlStatement, _commandBuilder); Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("TOP (top) ")); _stageMock.VerifyAllExpectations(); }
public void BuildSelectPart_WithDistinctAndTopExpression() { var sqlStatement = SqlStatementModelObjectMother.CreateMinimalSqlStatement(new SqlStatementBuilder { TopExpression = Expression.Constant(5), IsDistinctQuery = true }); _stageMock.Expect(mock => mock.GenerateTextForTopExpression(_commandBuilder, sqlStatement.TopExpression)) .WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("@1")); _stageMock.Expect( mock => mock.GenerateTextForSelectExpression(_commandBuilder, sqlStatement.SelectProjection)) .WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("[t].[ID],[t].[Name],[t].[City]")); _stageMock.Replay(); _generator.BuildSelectPart(sqlStatement, _commandBuilder, false); Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("SELECT DISTINCT TOP (@1) [t].[ID],[t].[Name],[t].[City]")); _stageMock.VerifyAllExpectations(); }
public void BuildOrderBy_WithSingleOrderByClause() { var columnExpression = new SqlColumnDefinitionExpression(typeof(string), "t", "Name", false); var orderByClause = new Ordering(columnExpression, OrderingDirection.Asc); var sqlStatement = SqlStatementModelObjectMother.CreateMinimalSqlStatement(new SqlStatementBuilder { Orderings = { orderByClause } }); _stageMock.Expect(mock => mock.GenerateTextForOrdering(_commandBuilder, orderByClause)) .WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("[t].[Name] ASC")); _stageMock.Replay(); _generator.BuildOrderByPart(sqlStatement, _commandBuilder); Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo(" ORDER BY [t].[Name] ASC")); _stageMock.VerifyAllExpectations(); }
public void BuildSetOperationCombinedStatementsPart_UnionAll() { var setOperationCombinedStatement = new SetOperationCombinedStatement(SqlStatementModelObjectMother.CreateSqlStatement(), SetOperation.UnionAll); var sqlStatement = SqlStatementModelObjectMother.CreateMinimalSqlStatement( new SqlStatementBuilder { SetOperationCombinedStatements = { setOperationCombinedStatement } }); _stageMock.Expect(mock => mock.GenerateTextForSqlStatement(_commandBuilder, setOperationCombinedStatement.SqlStatement)) .WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("statement")); _stageMock.Replay(); _generator.BuildSetOperationCombinedStatementsPart(sqlStatement, _commandBuilder); Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo(" UNION ALL (statement)")); _stageMock.VerifyAllExpectations(); }
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 SetUp() { _dataInfo = new StreamedScalarValueInfo(typeof(int)); _resolvedElementExpressionReference = new SqlColumnDefinitionExpression(typeof(string), "q0", "element", false); _resolvedSelectProjection = new NamedExpression( null, new AggregationExpression(typeof(int), _resolvedElementExpressionReference, AggregationModifier.Min)); _associatedGroupingSelectExpression = new SqlGroupingSelectExpression( new NamedExpression("key", Expression.Constant("k")), new NamedExpression("element", Expression.Constant("e"))); _resolvedJoinedGroupingSubStatement = SqlStatementModelObjectMother.CreateSqlStatement(_associatedGroupingSelectExpression); _resolvedJoinedGroupingTable = new SqlTable( new ResolvedJoinedGroupingTableInfo( "q1", _resolvedJoinedGroupingSubStatement, _associatedGroupingSelectExpression, "q0"), JoinSemantics.Inner); _simplifiableResolvedSqlStatement = SqlStatementModelObjectMother.CreateMinimalSqlStatement( new SqlStatementBuilder { DataInfo = _dataInfo, SelectProjection = _resolvedSelectProjection, SqlTables = { _resolvedJoinedGroupingTable } }); _simplifiableUnresolvedProjection = new AggregationExpression( typeof(int), new SqlTableReferenceExpression(_resolvedJoinedGroupingTable), AggregationModifier.Count); _stageMock = MockRepository.GenerateStrictMock <IMappingResolutionStage> (); _context = new MappingResolutionContext(); _groupAggregateSimplifier = new GroupAggregateSimplifier(_stageMock, _context); }
public void SetUp() { var sqlTable = SqlStatementModelObjectMother.CreateSqlTable_WithResolvedTableInfo(); _entityExpression = new SqlEntityDefinitionExpression( typeof(string), "t", null, e => e.GetColumn(typeof(string), "ID", true), new SqlColumnExpression[] { new SqlColumnDefinitionExpression(typeof(string), "t", "ID", true), new SqlColumnDefinitionExpression(typeof(int), "t", "Name", false), new SqlColumnDefinitionExpression(typeof(int), "t", "City", false) }); _sqlStatement = SqlStatementModelObjectMother.CreateMinimalSqlStatement( new SqlStatementBuilder { SelectProjection = _entityExpression, SqlTables = { sqlTable } }); _commandBuilder = new SqlCommandBuilder(); }