public void SetUp ()
{
_wrappedExpression = Expression.Constant (1);
_aggregationEpression = new AggregationExpression(typeof(int), _wrappedExpression, AggregationModifier.Max);
}
public Expression VisitAggregationExpression (AggregationExpression expression)
{
Expression newInnerExpression;
if (expression.AggregationModifier == AggregationModifier.Count)
newInnerExpression = ApplyValueContext (expression.Expression);
else
newInnerExpression = ApplySingleValueContext (expression.Expression);
if (newInnerExpression != expression.Expression)
return new AggregationExpression (expression.Type, newInnerExpression, expression.AggregationModifier);
return expression;
}
public void GetSqlStatement_CheckProperties ()
{
var dataInfo = new TestStreamedValueInfo (typeof (Cook));
var topExpression = ExpressionHelper.CreateExpression();
var isDistinctQuery = BooleanObjectMother.GetRandomBoolean();
var selectProjection = new AggregationExpression (typeof (int), Expression.Constant (1), AggregationModifier.Min);
var whereCondition = Expression.Constant (true);
var sqlTable = new SqlTable (new ResolvedSimpleTableInfo (typeof (Cook), "CookTable", "c"), JoinSemantics.Inner);
var ordering = new Ordering (Expression.Constant ("order"), OrderingDirection.Desc);
var rowNumberSelector = Expression.Constant ("selector");
var currentRowNumberOffset = Expression.Constant (1);
var groupExpression = Expression.Constant ("group");
var statementBuilder = new SqlStatementBuilder
{
DataInfo = dataInfo,
TopExpression = topExpression,
IsDistinctQuery = isDistinctQuery,
SelectProjection = selectProjection,
SqlTables = { sqlTable },
WhereCondition = whereCondition,
RowNumberSelector = rowNumberSelector,
CurrentRowNumberOffset = currentRowNumberOffset,
GroupByExpression = groupExpression,
Orderings = { ordering }
};
var sqlStatement = statementBuilder.GetSqlStatement();
Assert.That (sqlStatement.DataInfo, Is.SameAs (dataInfo));
Assert.That (sqlStatement.TopExpression, Is.SameAs (topExpression));
Assert.That (sqlStatement.IsDistinctQuery, Is.EqualTo (isDistinctQuery));
Assert.That (sqlStatement.SelectProjection, Is.SameAs (selectProjection));
Assert.That (sqlStatement.SqlTables[0], Is.SameAs (sqlTable));
Assert.That (sqlStatement.Orderings[0], Is.SameAs (ordering));
Assert.That (sqlStatement.WhereCondition, Is.SameAs (whereCondition));
Assert.That (sqlStatement.RowNumberSelector, Is.SameAs (rowNumberSelector));
Assert.That (sqlStatement.CurrentRowNumberOffset, Is.SameAs (currentRowNumberOffset));
Assert.That (sqlStatement.GroupByExpression, Is.SameAs (groupExpression));
}
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 = new SqlStatement (
_dataInfo,
_resolvedSelectProjection,
new[] { _resolvedJoinedGroupingTable },
null,
null,
new Ordering[0],
null,
false,
Expression.Constant (0),
Expression.Constant (0));
_simplifiableUnresolvedProjection = new AggregationExpression (
typeof (int),
new SqlTableReferenceExpression (_resolvedJoinedGroupingTable),
AggregationModifier.Count);
_stageMock = MockRepository.GenerateStrictMock<IMappingResolutionStage> ();
_context = new MappingResolutionContext();
_groupAggregateSimplifier = new GroupAggregateSimplifier (_stageMock, _context);
}
public void BuildSelectPart_WithAggregation ()
{
var aggregationExpression = new AggregationExpression (typeof(int), _entityExpression,AggregationModifier.Count);
var sqlStatement = new SqlStatementBuilder { SelectProjection = aggregationExpression, DataInfo = new TestStreamedValueInfo (typeof (object)) }.GetSqlStatement ();
_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 SimplifyIfPossible_SimplifiableStatement_AddsAggregationAndReturnsReference ()
{
Assert.That (_associatedGroupingSelectExpression.AggregationExpressions.Count, Is.EqualTo (0));
var expression = new SqlSubStatementExpression (_simplifiableResolvedSqlStatement);
var preparedResolvedAggregate = new AggregationExpression (
typeof (int),
new NamedExpression ("element", Expression.Constant ("e")),
AggregationModifier.Count);
_stageMock
.Expect (mock => mock.ResolveAggregationExpression(Arg<Expression>.Is.Anything, Arg.Is (_context)))
.Return (preparedResolvedAggregate)
.WhenCalled (mi => {
var expectedReplacedAggregate = new AggregationExpression (
typeof (int),
((NamedExpression) _associatedGroupingSelectExpression.ElementExpression).Expression,
AggregationModifier.Count);
SqlExpressionTreeComparer.CheckAreEqualTrees (expectedReplacedAggregate, (Expression) mi.Arguments[0]);
});
_stageMock.Replay();
var result = _groupAggregateSimplifier.SimplifyIfPossible (expression, _simplifiableUnresolvedProjection);
_stageMock.VerifyAllExpectations();
Assert.That (_associatedGroupingSelectExpression.AggregationExpressions.Count, Is.EqualTo (1));
Assert.That (
((NamedExpression) _associatedGroupingSelectExpression.AggregationExpressions[0]).Expression,
Is.SameAs (preparedResolvedAggregate));
var expected = new SqlColumnDefinitionExpression (typeof (int), "q0", "a0", false);
SqlExpressionTreeComparer.CheckAreEqualTrees (expected, result);
}
public void SimplifyIfPossible_WithNonSimplifiableProjection_ReturnsOriginalStatement ()
{
Assert.That (_associatedGroupingSelectExpression.AggregationExpressions.Count, Is.EqualTo (0));
var expression = new SqlSubStatementExpression (_simplifiableResolvedSqlStatement);
_stageMock.Replay ();
var nonSimplifiableProjection = new AggregationExpression (
typeof (int),
new SqlTableReferenceExpression (SqlStatementModelObjectMother.CreateSqlTable ()), AggregationModifier.Count);
var result = _groupAggregateSimplifier.SimplifyIfPossible (expression, nonSimplifiableProjection);
_stageMock.VerifyAllExpectations ();
var expected = new SqlSubStatementExpression (_simplifiableResolvedSqlStatement);
SqlExpressionTreeComparer.CheckAreEqualTrees (expected, result);
Assert.That (_associatedGroupingSelectExpression.AggregationExpressions.Count, Is.EqualTo (0));
}
public void VisitAggregationExpression_Average ()
{
var columnExpression = new NamedExpression (null, new SqlColumnDefinitionExpression (typeof (string), "c", "Name", false));
var expression = new AggregationExpression (typeof (double), columnExpression, AggregationModifier.Average);
SqlGeneratingExpressionVisitor.GenerateSql (expression, _commandBuilder, _stageMock);
Assert.That (_commandBuilder.GetCommandText(), Is.EqualTo ("AVG([c].[Name])"));
}
public void VisitAggregationExpression_Count ()
{
var columnExpression = new SqlColumnDefinitionExpression (typeof (string), "c", "Name", false);
var expression = new AggregationExpression (typeof (int), columnExpression, AggregationModifier.Count);
SqlGeneratingExpressionVisitor.GenerateSql (expression, _commandBuilder, _stageMock);
Assert.That (_commandBuilder.GetCommandText(), Is.EqualTo ("COUNT(*)"));
}
public void VisitAggregationExpression_ComplexValue_ThrowsWithOtherAggregations ()
{
var entity = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression ();
var aggregationExpression = new AggregationExpression (typeof (int), entity, AggregationModifier.Sum);
Assert.That (() => _valueRequiredVisitor.VisitExpression (aggregationExpression), Throws.TypeOf<NotSupportedException>());
}
public void VisitAggregationExpression_ComplexValue_AcceptedByCount ()
{
var entity = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression();
var aggregationExpression = new AggregationExpression (typeof (int), entity, AggregationModifier.Count);
var result = _singleValueRequiredVisitor.VisitExpression (aggregationExpression);
Assert.That (result, Is.SameAs (aggregationExpression));
}
public void VisitAggregationExpression_AppliesValueContextToInnerExpression ()
{
var aggregationExpression = new AggregationExpression (typeof (int), Expression.Constant (true), AggregationModifier.Count);
var result = _singleValueRequiredVisitor.VisitExpression (aggregationExpression);
var expected = new AggregationExpression (typeof (int), new SqlConvertedBooleanExpression (Expression.Constant (1)), AggregationModifier.Count);
SqlExpressionTreeComparer.CheckAreEqualTrees (expected, result);
}
public void CreateExpression_HasAggregationModifier ()
{
var sqlStatementBuilder = new SqlStatementBuilder (SqlStatementModelObjectMother.CreateSqlStatement());
sqlStatementBuilder.SqlTables.Clear();
var selectProjection = new AggregationExpression (typeof (double), sqlStatementBuilder.SelectProjection, AggregationModifier.Max);
sqlStatementBuilder.SelectProjection = selectProjection;
var sqlStatement = sqlStatementBuilder.GetSqlStatement();
var result = sqlStatement.CreateExpression();
Assert.That (result, Is.SameAs (selectProjection));
}
public void DifferentAggregationModifier ()
{
var dataInfo = new TestStreamedValueInfo (typeof (int));
var selectProjection = Expression.Constant (1);
var selectProjectionWithCountAggregation = new AggregationExpression (typeof (int), selectProjection, AggregationModifier.Count);
var sqlStatement1 = new SqlStatement (
dataInfo,
selectProjectionWithCountAggregation,
new SqlTable[] { },
null,
null,
new Ordering[] { },
null,
false,
null,
null);
var sqlStatement2 = new SqlStatement (
dataInfo,
selectProjection,
new SqlTable[] { },
null,
null,
new Ordering[] { },
null,
false,
null,
null);
Assert.That (sqlStatement1.Equals (sqlStatement2), Is.False);
}