public void ParseApplyWithNestedAggregation()
{
string apply = "groupby((UnitPrice), aggregate(Sales($count as Count)))";
IEnumerable <QueryToken> actual = this.testSubject.ParseApply(apply);
actual.Should().NotBeNull();
actual.Should().HaveCount(1);
List <QueryToken> transformations = actual.ToList();
// verify groupby
GroupByToken groupBy = transformations[0] as GroupByToken;
groupBy.Should().NotBeNull();
VerifyGroupByTokenProperties(new string[] { "UnitPrice" }, groupBy);
groupBy.Properties.Should().HaveCount(1);
groupBy.Child.Should().NotBeNull();
AggregateToken groupByAggregate = groupBy.Child as AggregateToken;
groupByAggregate.AggregateExpressions.Should().HaveCount(1);
EntitySetAggregateToken entitySetAggregate = groupByAggregate.AggregateExpressions.First() as EntitySetAggregateToken;
entitySetAggregate.Should().NotBeNull();
entitySetAggregate.EntitySet.ShouldBeEndPathToken("Sales");
VerifyAggregateExpressionToken("$count", AggregationMethodDefinition.VirtualPropertyCount, "Count", entitySetAggregate.Expressions.First() as AggregateExpressionToken);
}
/// <summary>
/// Merges two <see cref="EntitySetAggregateToken"/> that have the same entity set into one.
/// If the parameters do not share the the entity set, an exception is thrown.
/// </summary>
/// <param name="token1">First token that is going to be merged.</param>
/// <param name="token2">Second token that is going to be merged.</param>
/// <returns>
/// Returns a token with the same entitySet as the parameters and with expressions from both objects.
/// </returns>
public static EntitySetAggregateToken Merge(EntitySetAggregateToken token1, EntitySetAggregateToken token2)
{
if (token1 == null)
{
return(token2);
}
if (token2 == null)
{
return(token1);
}
ExceptionUtils.Equals(token1.entitySet, token2.entitySet);
return(new EntitySetAggregateToken(token1.entitySet, token1.expressions.Concat(token2.expressions)));
}
public void ParseApplyWithNestedFunctionAggregation()
{
string apply = "groupby((UnitPrice), aggregate(Sales($count as Count, cast(SalesPrice, Edm.Decimal) with average as RetailPrice)))";
IEnumerable <QueryToken> actual = this.testSubject.ParseApply(apply);
actual.Should().NotBeNull();
actual.Should().HaveCount(1);
List <QueryToken> transformations = actual.ToList();
// verify groupby
GroupByToken groupBy = transformations[0] as GroupByToken;
groupBy.Should().NotBeNull();
VerifyGroupByTokenProperties(new string[] { "UnitPrice" }, groupBy);
groupBy.Properties.Should().HaveCount(1);
groupBy.Child.Should().NotBeNull();
AggregateToken groupByAggregate = groupBy.Child as AggregateToken;
groupByAggregate.AggregateExpressions.Should().HaveCount(1);
EntitySetAggregateToken entitySetAggregate = groupByAggregate.AggregateExpressions.First() as EntitySetAggregateToken;
entitySetAggregate.Should().NotBeNull();
entitySetAggregate.EntitySet.ShouldBeEndPathToken("Sales");
entitySetAggregate.Expressions.Should().HaveCount(2);
VerifyAggregateExpressionToken("$count", AggregationMethodDefinition.VirtualPropertyCount, "Count", entitySetAggregate.Expressions.First() as AggregateExpressionToken);
AggregateExpressionToken funcAggregate = entitySetAggregate.Expressions.Last() as AggregateExpressionToken;
funcAggregate.Should().NotBeNull();
funcAggregate.Alias.ShouldBeEquivalentTo("RetailPrice");
funcAggregate.Method.Should().Equals(AggregationMethodDefinition.Average);
FunctionCallToken funcToken = funcAggregate.Expression as FunctionCallToken;
funcToken.Should().NotBeNull();
funcToken.Name.ShouldBeEquivalentTo("cast");
}
public void ParseApplyWithNestedAggregationAndFunction()
{
string apply = "groupby((UnitPrice), aggregate(Sales($count as Count), cast(SalesPrice, Edm.Decimal) with average as RetailPrice))";
IEnumerable <QueryToken> actual = this.testSubject.ParseApply(apply);
Assert.NotNull(actual);
Assert.Single(actual);
List <QueryToken> transformations = actual.ToList();
// verify groupby
GroupByToken groupBy = transformations[0] as GroupByToken;
Assert.NotNull(groupBy);
VerifyGroupByTokenProperties(new string[] { "UnitPrice" }, groupBy);
Assert.Single(groupBy.Properties);
Assert.NotNull(groupBy.Child);
AggregateToken groupByAggregate = groupBy.Child as AggregateToken;
Assert.Equal(2, groupByAggregate.AggregateExpressions.Count());
EntitySetAggregateToken entitySetAggregate = groupByAggregate.AggregateExpressions.First() as EntitySetAggregateToken;
Assert.NotNull(entitySetAggregate);
entitySetAggregate.EntitySet.ShouldBeEndPathToken("Sales");
VerifyAggregateExpressionToken("$count", AggregationMethodDefinition.VirtualPropertyCount, "Count", entitySetAggregate.Expressions.First() as AggregateExpressionToken);
AggregateExpressionToken funcAggregate = groupByAggregate.AggregateExpressions.Last() as AggregateExpressionToken;
Assert.NotNull(funcAggregate);
Assert.Equal("RetailPrice", funcAggregate.Alias);
Assert.Equal(AggregationMethod.Average, funcAggregate.Method);
FunctionCallToken funcToken = funcAggregate.Expression as FunctionCallToken;
Assert.NotNull(funcToken);
Assert.Equal("cast", funcToken.Name);
}
/// <summary>
/// Visits an EntitySetAggregateToken
/// </summary>
/// <param name="tokenIn">The EntitySetAggregateToken to visit</param>
/// <returns>A T bound to this EntitySetAggregateToken</returns>
public virtual T Visit(EntitySetAggregateToken tokenIn)
{
throw new NotImplementedException();
}
public Expression Visit(EntitySetAggregateToken tokenIn)
{
throw new NotImplementedException();
}
public bool Visit(EntitySetAggregateToken tokenIn)
{
throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, "QueryToken of type '{0}' is not supported.", tokenIn.Kind));
}
