public override void Visit(DbGroupByExpression e)
{
Check.NotNull <DbGroupByExpression>(e, nameof(e));
this.VisitExprKind(e.ExpressionKind);
this._key.Append('(');
this.VisitGroupBinding(e.Input);
foreach (DbExpression key in (IEnumerable <DbExpression>)e.Keys)
{
this._key.Append("K(");
key.Accept((DbExpressionVisitor)this);
this._key.Append(')');
}
foreach (DbAggregate aggregate in (IEnumerable <DbAggregate>)e.Aggregates)
{
DbGroupAggregate dbGroupAggregate = aggregate as DbGroupAggregate;
if (dbGroupAggregate != null)
{
this._key.Append("GA(");
dbGroupAggregate.Arguments[0].Accept((DbExpressionVisitor)this);
this._key.Append(')');
}
else
{
this._key.Append("A:");
DbFunctionAggregate functionAggregate = (DbFunctionAggregate)aggregate;
if (functionAggregate.Distinct)
{
this._key.Append("D:");
}
this.VisitFunction(functionAggregate.Function, functionAggregate.Arguments);
}
}
this._key.Append(')');
}
public override void Visit(DbGroupByExpression e)
{
Check.NotNull <DbGroupByExpression>(e, nameof(e));
this.Begin((DbExpression)e);
this.Dump(e.Input, "Input");
this.Dump((IEnumerable <DbExpression>)e.Keys, "Keys", "Key");
this.Begin("Aggregates");
foreach (DbAggregate aggregate in (IEnumerable <DbAggregate>)e.Aggregates)
{
DbFunctionAggregate functionAggregate = aggregate as DbFunctionAggregate;
if (functionAggregate != null)
{
this.Begin("DbFunctionAggregate");
this.Dump(functionAggregate.Function);
this.Dump((IEnumerable <DbExpression>)functionAggregate.Arguments, "Arguments", "Argument");
this.End("DbFunctionAggregate");
}
else
{
DbGroupAggregate dbGroupAggregate = aggregate as DbGroupAggregate;
this.Begin("DbGroupAggregate");
this.Dump((IEnumerable <DbExpression>)dbGroupAggregate.Arguments, "Arguments", "Argument");
this.End("DbGroupAggregate");
}
}
this.End("Aggregates");
this.End((DbExpression)e);
}
public override void Visit(DbGroupByExpression e)
{
Begin(e);
Dump(e.Input, "Input");
Dump(e.Keys, "Keys", "Key");
Begin("Aggregates");
foreach (DbAggregate agg in e.Aggregates)
{
DbFunctionAggregate funcAgg = agg as DbFunctionAggregate;
if (funcAgg != null)
{
Begin("DbFunctionAggregate");
Dump(funcAgg.Function);
Dump(funcAgg.Arguments, "Arguments", "Argument");
End("DbFunctionAggregate");
}
else
{
DbGroupAggregate groupAgg = agg as DbGroupAggregate;
Debug.Assert(groupAgg != null, "Invalid DbAggregate");
Begin("DbGroupAggregate");
Dump(groupAgg.Arguments, "Arguments", "Argument");
End("DbGroupAggregate");
}
}
End("Aggregates");
End(e);
}
public override TreeNode Visit(DbGroupByExpression e)
{
List <TreeNode> keys = new List <TreeNode>();
List <TreeNode> aggs = new List <TreeNode>();
RowType outputType = TypeHelpers.GetEdmType <RowType>(TypeHelpers.GetEdmType <CollectionType>(e.ResultType).TypeUsage);
int keyIdx = 0;
for (int idx = 0; idx < e.Keys.Count; idx++)
{
keys.Add(this.VisitWithLabel("Key", outputType.Properties[idx].Name, e.Keys[keyIdx]));
keyIdx++;
}
int aggIdx = 0;
for (int idx = e.Keys.Count; idx < outputType.Properties.Count; idx++)
{
TreeNode aggInfo = new TreeNode("Aggregate : '");
aggInfo.Text.Append(outputType.Properties[idx].Name);
aggInfo.Text.Append("'");
DbFunctionAggregate funcAgg = e.Aggregates[aggIdx] as DbFunctionAggregate;
if (funcAgg != null)
{
TreeNode funcInfo = this.VisitFunction(funcAgg.Function, funcAgg.Arguments);
if (funcAgg.Distinct)
{
funcInfo = new TreeNode("Distinct", funcInfo);
}
aggInfo.Children.Add(funcInfo);
}
else
{
DbGroupAggregate groupAgg = e.Aggregates[aggIdx] as DbGroupAggregate;
Debug.Assert(groupAgg != null, "Invalid DbAggregate");
aggInfo.Children.Add(this.Visit("GroupAggregate", groupAgg.Arguments[0]));
}
aggs.Add(aggInfo);
aggIdx++;
}
TreeNode retInfo = NodeFromExpression(e);
retInfo.Children.Add(this.VisitGroupBinding(e.Input));
if (keys.Count > 0)
{
retInfo.Children.Add(new TreeNode("Keys", keys));
}
if (aggs.Count > 0)
{
retInfo.Children.Add(new TreeNode("Aggregates", aggs));
}
return(retInfo);
}
public override TreeNode Visit(DbGroupByExpression e)
{
Check.NotNull <DbGroupByExpression>(e, nameof(e));
List <TreeNode> children1 = new List <TreeNode>();
List <TreeNode> children2 = new List <TreeNode>();
RowType edmType = TypeHelpers.GetEdmType <RowType>(TypeHelpers.GetEdmType <CollectionType>(e.ResultType).TypeUsage);
int index1 = 0;
for (int index2 = 0; index2 < e.Keys.Count; ++index2)
{
children1.Add(this.VisitWithLabel("Key", edmType.Properties[index2].Name, e.Keys[index1]));
++index1;
}
int index3 = 0;
for (int count = e.Keys.Count; count < edmType.Properties.Count; ++count)
{
TreeNode treeNode1 = new TreeNode("Aggregate : '", new TreeNode[0]);
treeNode1.Text.Append(edmType.Properties[count].Name);
treeNode1.Text.Append("'");
DbFunctionAggregate aggregate1 = e.Aggregates[index3] as DbFunctionAggregate;
if (aggregate1 != null)
{
TreeNode treeNode2 = this.VisitFunction(aggregate1.Function, aggregate1.Arguments);
if (aggregate1.Distinct)
{
treeNode2 = new TreeNode("Distinct", new TreeNode[1]
{
treeNode2
});
}
treeNode1.Children.Add(treeNode2);
}
else
{
DbGroupAggregate aggregate2 = e.Aggregates[index3] as DbGroupAggregate;
treeNode1.Children.Add(this.Visit("GroupAggregate", aggregate2.Arguments[0]));
}
children2.Add(treeNode1);
++index3;
}
TreeNode treeNode = ExpressionPrinter.PrinterVisitor.NodeFromExpression((DbExpression)e);
treeNode.Children.Add(this.VisitGroupBinding(e.Input));
if (children1.Count > 0)
{
treeNode.Children.Add(new TreeNode("Keys", children1));
}
if (children2.Count > 0)
{
treeNode.Children.Add(new TreeNode("Aggregates", children2));
}
return(treeNode);
}
