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