protected virtual Expression VisitAggregate(AggregateExpression aggregate)
{
var exp = Visit(aggregate.Argument);
if (exp != aggregate.Argument)
return new AggregateExpression(aggregate.Type, aggregate.AggregateType, exp, aggregate.Distinct);
return aggregate;
}
private void AverageAggregate(AggregateExpression aggregate)
{
var old = _currentAggregateName;
_currentAggregateName = old + "Cnt";
CountAggregate(aggregate);
_currentAggregateName = old + "Sum";
SumAggregate(aggregate);
_currentAggregateName = old;
}
protected virtual Expression VisitAggregate(AggregateExpression aggregate)
{
var exp = Visit(aggregate.Argument);
if (exp != aggregate.Argument)
{
return(new AggregateExpression(aggregate.Type, aggregate.AggregateType, exp, aggregate.Distinct));
}
return(aggregate);
}
protected override Expression VisitAggregate(AggregateExpression aggregate)
{
switch (aggregate.AggregateType)
{
case AggregateType.Average:
_returnValues.Add(new KeyValuePair<string, string>(_currentAggregateName, string.Format("value.{0}Sum/value.{0}Cnt", _currentAggregateName)));
break;
case AggregateType.Count:
case AggregateType.Max:
case AggregateType.Min:
case AggregateType.Sum:
_returnValues.Add(new KeyValuePair<string, string>(_currentAggregateName, "value." + _currentAggregateName));
break;
}
return aggregate;
}
protected override Expression VisitAggregate(AggregateExpression aggregate)
{
switch (aggregate.AggregateType)
{
case AggregateType.Average:
_initMap[_currentAggregateName + "Sum"] = _formatter.FormatJavascript(aggregate.Argument);
_initMap[_currentAggregateName + "Cnt"] = "1";
break;
case AggregateType.Count:
_initMap[_currentAggregateName] = "1";
break;
case AggregateType.Max:
case AggregateType.Min:
case AggregateType.Sum:
_initMap[_currentAggregateName] = _formatter.FormatJavascript(aggregate.Argument);
break;
}
return aggregate;
}
protected override Expression VisitAggregate(AggregateExpression aggregate)
{
switch (aggregate.AggregateType)
{
case AggregateType.Average:
AverageAggregate(aggregate);
break;
case AggregateType.Count:
CountAggregate(aggregate);
break;
case AggregateType.Max:
MaxAggregate(aggregate);
break;
case AggregateType.Min:
MinAggregate(aggregate);
break;
case AggregateType.Sum:
SumAggregate(aggregate);
break;
}
return aggregate;
}
private Expression BindAggregate(Expression source, MethodInfo method, LambdaExpression argument, bool isRoot)
{
var returnType = method.ReturnType;
var aggregateType = GetAggregateType(method.Name);
bool hasPredicateArgument = HasPredicateArgument(aggregateType);
bool distinct = false;
bool argumentWasPredicate = false;
var methodCallExpression = source as MethodCallExpression;
if (methodCallExpression != null && !hasPredicateArgument && argument == null)
{
if (methodCallExpression.Method.Name == "Distinct" && methodCallExpression.Arguments.Count == 1
&& (methodCallExpression.Method.DeclaringType == typeof(Queryable) || methodCallExpression.Method.DeclaringType == typeof(Enumerable)))
{
source = methodCallExpression.Arguments[0];
distinct = true;
}
}
if (argument != null && hasPredicateArgument)
{
source = Expression.Call(typeof(Queryable), "Where", method.GetGenericArguments(), source, argument);
argument = null;
argumentWasPredicate = true;
}
var projection = VisitSequence(source);
Expression argExpression = null;
if (argument != null)
{
_map[argument.Parameters[0]] = projection.Projector;
argExpression = Visit(argument.Body);
}
else if (!hasPredicateArgument)
argExpression = projection.Projector;
var alias = new Alias();
Expression aggregateExpression = new AggregateExpression(returnType, aggregateType, argExpression, distinct);
var selectType = typeof(IEnumerable<>).MakeGenericType(returnType);
string fieldName = "_$agg" + (_aggregateCount++);
var select = new SelectExpression(alias, new[] { new FieldDeclaration(fieldName, aggregateExpression) }, projection.Source, null);
if (isRoot)
{
var parameter = Expression.Parameter(selectType, "p");
var lambda = Expression.Lambda(Expression.Call(typeof(Enumerable), "Single", new[] { returnType }, parameter), parameter);
return new ProjectionExpression(
select,
new FieldExpression(aggregateExpression, alias, fieldName),
lambda);
}
var subquery = new ScalarExpression(returnType, select);
GroupByInfo info;
if (!argumentWasPredicate && _groupByMap.TryGetValue(projection, out info))
{
if (argument != null)
{
_map[argument.Parameters[0]] = info.Element;
argExpression = Visit(argument.Body);
}
else if (!hasPredicateArgument)
argExpression = info.Element;
aggregateExpression = new AggregateExpression(returnType, aggregateType, argExpression, distinct);
if (projection == _currentGroupElement)
return aggregateExpression;
return new AggregateSubqueryExpression(info.Alias, aggregateExpression, subquery);
}
return subquery;
}
protected override Expression VisitAggregate(AggregateExpression aggregate)
{
return aggregate;
}
protected override Expression VisitAggregate(AggregateExpression aggregate)
{
_hasAggregate = true;
return aggregate;
}
protected virtual bool CompareAggregate(AggregateExpression a, AggregateExpression b)
{
return(a.AggregateType == b.AggregateType && Compare(a.Argument, b.Argument));
}
protected virtual bool CompareAggregate(AggregateExpression a, AggregateExpression b)
{
return a.AggregateType == b.AggregateType && Compare(a.Argument, b.Argument);
}
private void MaxAggregate(AggregateExpression aggregate)
{
_declare.AppendFormat("var {0} = Number.MIN_VALUE;", _currentAggregateName);
_loop.AppendFormat("if(doc.{0} > {0}) {0} = doc.{0};", _currentAggregateName);
_returnValues.Add(new KeyValuePair<string, string>(_currentAggregateName, _currentAggregateName));
}
private void CountAggregate(AggregateExpression aggregate)
{
_declare.AppendFormat("var {0} = 0;", _currentAggregateName);
_loop.AppendFormat("{0} += doc.{0};", _currentAggregateName);
_returnValues.Add(new KeyValuePair<string, string>(_currentAggregateName, _currentAggregateName));
}
