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); }