public override void HandleResultOperator(
GroupResultOperator resultOperator,
SqlStatementBuilder sqlStatementBuilder,
UniqueIdentifierGenerator generator,
ISqlPreparationStage stage,
ISqlPreparationContext context)
{
ArgumentUtility.CheckNotNull("resultOperator", resultOperator);
ArgumentUtility.CheckNotNull("sqlStatementBuilder", sqlStatementBuilder);
ArgumentUtility.CheckNotNull("generator", generator);
ArgumentUtility.CheckNotNull("stage", stage);
ArgumentUtility.CheckNotNull("context", context);
EnsureNoTopExpression(sqlStatementBuilder, generator, stage, context);
EnsureNoGroupExpression(sqlStatementBuilder, generator, stage, context);
EnsureNoDistinctQuery(sqlStatementBuilder, generator, stage, context);
UpdateDataInfo(resultOperator, sqlStatementBuilder, sqlStatementBuilder.DataInfo);
var preparedKeySelector = stage.PrepareResultOperatorItemExpression(resultOperator.KeySelector, context);
preparedKeySelector = HandlePotentialConstantExpression(preparedKeySelector);
preparedKeySelector = HandlePotentialSubStatementExpression(preparedKeySelector, sqlStatementBuilder, generator);
var preparedElementSelector = stage.PrepareResultOperatorItemExpression(resultOperator.ElementSelector, context);
sqlStatementBuilder.GroupByExpression = preparedKeySelector;
sqlStatementBuilder.SelectProjection = SqlGroupingSelectExpression.CreateWithNames(preparedKeySelector, preparedElementSelector);
}
public void CreateWithNames()
{
var result = SqlGroupingSelectExpression.CreateWithNames(_keyExpression, _elementExpression);
var expectedKeyExpression = new NamedExpression("key", _keyExpression);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedKeyExpression, result.KeyExpression);
var expectedElementExpression = new NamedExpression("element", _elementExpression);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedElementExpression, result.ElementExpression);
}
public void VisitSqlGroupingSelectExpression_WithAggregationExpressions_AndNames()
{
var groupingExpression = SqlGroupingSelectExpression.CreateWithNames(Expression.Constant("keyExpression"), Expression.Constant("elementExpression"));
groupingExpression.AddAggregationExpressionWithName(Expression.Constant("aggregation1"));
groupingExpression.AddAggregationExpressionWithName(Expression.Constant("aggregation2"));
SqlGeneratingSelectExpressionVisitor.GenerateSql(groupingExpression, _commandBuilder, _stageMock);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("@1 AS [key], @2 AS [a0], @3 AS [a1]"));
Assert.That(_commandBuilder.GetCommandParameters()[0].Value, Is.EqualTo("keyExpression"));
Assert.That(_commandBuilder.GetCommandParameters()[1].Value, Is.EqualTo("aggregation1"));
Assert.That(_commandBuilder.GetCommandParameters()[2].Value, Is.EqualTo("aggregation2"));
}
public void HandleResultOperator_DetectConstantKeysAndReplaceWithSubStatement()
{
var keySelector = Expression.Constant("keySelector");
var elementSelector = Expression.Constant("elementSelector");
var resultOperator = new GroupResultOperator("itemName", keySelector, elementSelector);
var preparedConstantKeySelector = Expression.Constant("test");
_stageMock
.Expect(mock => mock.PrepareResultOperatorItemExpression(keySelector, _context))
.Return(preparedConstantKeySelector);
_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 expectedSelectExpression = new NamedExpression(null, preparedConstantKeySelector);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedSelectExpression, groupKeyTableTableInfo.SqlStatement.SelectProjection);
var expectedStatement = new SqlStatementBuilder
{
DataInfo = new StreamedSequenceInfo(typeof(IEnumerable <string>), groupKeyTableTableInfo.SqlStatement.SelectProjection),
SelectProjection = groupKeyTableTableInfo.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 Expression VisitSqlGroupingSelectExpression(SqlGroupingSelectExpression expression)
{
ArgumentUtility.CheckNotNull("expression", expression);
var referenceToKeyExpression = ResolveChildExpression(expression.KeyExpression);
var referenceToElementExpression = ResolveChildExpression(expression.ElementExpression);
var referenceToAggregationExpressions = expression.AggregationExpressions.Select(expr => ResolveChildExpression(expr));
var newGroupingExpression = SqlGroupingSelectExpression.CreateWithNames(referenceToKeyExpression, referenceToElementExpression);
foreach (var aggregationExpression in referenceToAggregationExpressions)
{
newGroupingExpression.AddAggregationExpressionWithName(aggregationExpression);
}
_context.AddGroupReferenceMapping(newGroupingExpression, _sqlTable);
return(newGroupingExpression);
}
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));
}
