public IQueryable Bind(IQueryable query)
{
PreprocessQuery(query);
// compute(X add Y as Z, A mul B as C) adds new properties to the output
// Should return following expression
// .Select($it => new ComputeWrapper<T> {
// Instance = $it,
// Container => new AggregationPropertyContainer() {
// Name = "X",
// Value = $it.X + $it.Y,
// Next = new LastInChain() {
// Name = "C",
// Value = $it.A * $it.B
// }
// })
List <MemberAssignment> wrapperTypeMemberAssignments = new List <MemberAssignment>();
// Set Instance property
var wrapperProperty = this.ResultClrType.GetProperty("Instance");
wrapperTypeMemberAssignments.Add(Expression.Bind(wrapperProperty, this._lambdaParameter));
var properties = new List <NamedPropertyExpression>();
foreach (var computeExpression in this._transformation.ComputeClause.ComputedItems)
{
properties.Add(new NamedPropertyExpression(Expression.Constant(computeExpression.Alias), CreateComputeExpression(computeExpression)));
}
// Set new compute properties
wrapperProperty = ResultClrType.GetProperty("Container");
wrapperTypeMemberAssignments.Add(Expression.Bind(wrapperProperty, AggregationPropertyContainer.CreateNextNamedPropertyContainer(properties)));
var initilizedMember =
Expression.MemberInit(Expression.New(ResultClrType), wrapperTypeMemberAssignments);
var selectLambda = Expression.Lambda(initilizedMember, this._lambdaParameter);
var result = ExpressionHelpers.Select(query, selectLambda, this._elementType);
return(result);
}
private List <NamedPropertyExpression> CreateGroupByMemberAssignments(IEnumerable <GroupByPropertyNode> nodes)
{
var properties = new List <NamedPropertyExpression>();
foreach (var grpProp in nodes)
{
var propertyName = grpProp.Name;
if (grpProp.Expression != null)
{
properties.Add(new NamedPropertyExpression(Expression.Constant(propertyName), WrapConvert(BindAccessor(grpProp.Expression))));
}
else
{
var wrapperProperty = typeof(GroupByWrapper).GetProperty("GroupByContainer");
List <MemberAssignment> wta = new List <MemberAssignment>();
wta.Add(Expression.Bind(wrapperProperty, AggregationPropertyContainer.CreateNextNamedPropertyContainer(CreateGroupByMemberAssignments(grpProp.ChildTransformations))));
properties.Add(new NamedPropertyExpression(Expression.Constant(propertyName), Expression.MemberInit(Expression.New(typeof(GroupByWrapper)), wta)));
}
}
return(properties);
}
private IQueryable BindGroupBy(IQueryable query)
{
LambdaExpression groupLambda = null;
Type elementType = query.ElementType;
if (_groupingProperties != null && _groupingProperties.Any())
{
// Generates expression
// .GroupBy($it => new DynamicTypeWrapper()
// {
// GroupByContainer => new AggregationPropertyContainer() {
// Name = "Prop1",
// Value = $it.Prop1,
// Next = new AggregationPropertyContainer() {
// Name = "Prop2",
// Value = $it.Prop2, // int
// Next = new LastInChain() {
// Name = "Prop3",
// Value = $it.Prop3
// }
// }
// }
// })
List <NamedPropertyExpression> properties = CreateGroupByMemberAssignments(_groupingProperties);
var wrapperProperty = typeof(GroupByWrapper).GetProperty(GroupByContainerProperty);
List <MemberAssignment> wta = new List <MemberAssignment>();
wta.Add(Expression.Bind(wrapperProperty, AggregationPropertyContainer.CreateNextNamedPropertyContainer(properties)));
groupLambda = Expression.Lambda(Expression.MemberInit(Expression.New(typeof(GroupByWrapper)), wta), _lambdaParameter);
}
else
{
// We do not have properties to aggregate
// .GroupBy($it => new NoGroupByWrapper())
groupLambda = Expression.Lambda(Expression.New(this._groupByClrType), this._lambdaParameter);
}
return(ExpressionHelpers.GroupBy(query, groupLambda, elementType, this._groupByClrType));
}
/// <summary>
/// Pre flattens properties referenced in aggregate clause to avoid generation of nested queries by EF.
/// For query like groupby((A), aggregate(B/C with max as Alias1, B/D with max as Alias2)) we need to generate
/// .Select(
/// $it => new FlattenninWrapper () {
/// Source = $it, // Will used in groupby stage
/// Container = new {
/// Value = $it.B.C
/// Next = new {
/// Value = $it.B.D
/// }
/// }
/// }
/// )
/// Also we need to populate expressions to access B/C and B/D in aggregate stage. It will look like:
/// B/C : $it.Container.Value
/// B/D : $it.Container.Next.Value
/// </summary>
/// <param name="query"></param>
/// <returns>Query with Select that flattens properties</returns>
private IQueryable FlattenReferencedProperties(IQueryable query)
{
if (_aggregateExpressions != null &&
_aggregateExpressions.Any(e => e.Method != AggregationMethod.VirtualPropertyCount) &&
_groupingProperties != null &&
_groupingProperties.Any() &&
(FlattenedPropertyContainer == null || !FlattenedPropertyContainer.Any())
)
{
var wrapperType = typeof(FlatteningWrapper <>).MakeGenericType(this._elementType);
var sourceProperty = wrapperType.GetProperty("Source");
List <MemberAssignment> wta = new List <MemberAssignment>();
wta.Add(Expression.Bind(sourceProperty, this._lambdaParameter));
var aggrregatedPropertiesToFlatten = _aggregateExpressions.Where(e => e.Method != AggregationMethod.VirtualPropertyCount).ToList();
// Generated Select will be stack like, meaning that first property in the list will be deepest one
// For example if we add $it.B.C, $it.B.D, select will look like
// new {
// Value = $it.B.C
// Next = new {
// Value = $it.B.D
// }
// }
// We are generated references (in currentContainerExpression) from the begining of the Select ($it.Value, then $it.Next.Value etc.)
// We have proper match we need insert properties in reverse order
// After this
// properties = { $it.B.D, $it.B.C}
// _preFlattendMAp = { {$it.B.C, $it.Value}, {$it.B.D, $it.Next.Value} }
var properties = new NamedPropertyExpression[aggrregatedPropertiesToFlatten.Count];
var aliasIdx = aggrregatedPropertiesToFlatten.Count - 1;
var aggParam = Expression.Parameter(wrapperType, "$it");
var currentContainerExpression = Expression.Property(aggParam, GroupByContainerProperty);
foreach (var aggExpression in aggrregatedPropertiesToFlatten)
{
var alias = "Property" + aliasIdx; // We just need unique alias, we aren't going to use it
// Add Value = $it.B.C
var propAccessExpression = BindAccessor(aggExpression.Expression);
var type = propAccessExpression.Type;
propAccessExpression = WrapConvert(propAccessExpression);
properties[aliasIdx] = new NamedPropertyExpression(Expression.Constant(alias), propAccessExpression);
// Save $it.Container.Next.Value for future use
UnaryExpression flatAccessExpression = Expression.Convert(
Expression.Property(currentContainerExpression, "Value"),
type);
currentContainerExpression = Expression.Property(currentContainerExpression, "Next");
_preFlattenedMap.Add(aggExpression.Expression, flatAccessExpression);
aliasIdx--;
}
var wrapperProperty = ResultClrType.GetProperty(GroupByContainerProperty);
wta.Add(Expression.Bind(wrapperProperty, AggregationPropertyContainer.CreateNextNamedPropertyContainer(properties)));
var flatLambda = Expression.Lambda(Expression.MemberInit(Expression.New(wrapperType), wta), _lambdaParameter);
query = ExpressionHelpers.Select(query, flatLambda, this._elementType);
// We applied flattening let .GroupBy know about it.
this._lambdaParameter = aggParam;
this._elementType = wrapperType;
}
return(query);
}