public void Visit(GroupByNode node) { Fields = node.GroupNames .Select((n, i) => new KeyValuePair <string, Type>(n, node.GroupTypes[i])) .Concat(node.AggregateNames.Select((n, i) => new KeyValuePair <string, Type>(n, node.AggregateTypes[i]))) .ToDictionary(k => k.Key, k => k.Value); }
public void Visit(QueryNode node) { var orderBy = node.OrderBy != null?Nodes.Pop() as OrderByNode : null; var take = node.Take != null?Nodes.Pop() as TakeNode : null; var skip = node.Skip != null?Nodes.Pop() as SkipNode : null; var select = Nodes.Pop() as SelectNode; var groupBy = node.GroupBy != null?Nodes.Pop() as GroupByNode : null; var where = node.Where != null?Nodes.Pop() as WhereNode : null; var from = Nodes.Pop() as FromNode; if (groupBy == null && _refreshMethods.Count > 0) { groupBy = new GroupByNode( new[] { new FieldNode(new IntegerNode("1"), 0, string.Empty) }, null); } _currentScope.ScopeSymbolTable.AddSymbol(from.Alias.ToRefreshMethodsSymbolName(), new RefreshMethodsSymbol(_refreshMethods)); _refreshMethods.Clear(); if (_currentScope.ScopeSymbolTable.SymbolIsOfType <TableSymbol>(string.Empty)) { _currentScope.ScopeSymbolTable.MoveSymbol(string.Empty, from.Alias); } Methods.Push(from.Alias); Nodes.Push(new QueryNode(select, from, where, groupBy, orderBy, skip, take)); _schemaFromArgs.Clear(); }
public virtual void Visit(GroupByNode node) { foreach (var field in node.Fields) { field.Accept(this); } node.Having?.Accept(this); node.Accept(Visitor); }
public void Visit(GroupByNode node) { SetQueryPart(QueryPart.GroupBy); foreach (var field in node.Fields) { field.Accept(this); } node.Accept(_visitor); node.Having?.Accept(this); }
public void Visit(GroupByNode node) { SetQueryPart(QueryPart.GroupBy); Expression sequence = _visitor.Nodes.Peek(); this._visitor.ScopedParamters.Push(Expression.Parameter(sequence.GetElementType(), "item_" + sequence.GetElementType().Name)); foreach (var field in node.Fields) field.Accept(this); node.Accept(_visitor); node.Having?.Accept(this); }
public virtual void Visit(GroupByNode node) { var having = Nodes.Peek() as HavingNode; if (having != null) { Nodes.Pop(); } var fields = new FieldNode[node.Fields.Length]; for (var i = node.Fields.Length - 1; i >= 0; --i) { fields[i] = Nodes.Pop() as FieldNode; } Nodes.Push(new GroupByNode(fields, having)); }
public override void Visit(GroupByNode node) { var fields = new FieldNode[node.Fields.Length]; HavingNode having = null; if (node.Having != null) { having = (HavingNode)Nodes.Pop(); } for (int i = 0, j = fields.Length - 1; i < fields.Length; i++, j--) { fields[j] = (FieldNode)Nodes.Pop(); } ChangedGroupBy = new GroupByNode(fields, having); }
public void Visit(GroupByNode node) { var having = Nodes.Peek() as HavingNode; if (having != null) { Nodes.Pop(); } var fields = new FieldNode[node.Fields.Length]; for (var i = node.Fields.Length - 1; i >= 0; --i) { var field = Nodes.Pop() as FieldNode; _groupByFields.Insert(0, field); fields[i] = field; } Nodes.Push(new GroupByNode(fields, having)); }
public void Visit(GroupByNode node) => VisitInternal(node);
public void Visit(GroupByNode node) { node.Inner[0].Accept(this); Mode = Query.EvaluationMode.Aggregate; }
public override void Visit(GroupByNode node) { Visitor.SetQueryPart(QueryPart.GroupBy); base.Visit(node); Visitor.SetQueryPart(QueryPart.None); }
/// <summary> /// Creates a query tree for the given query elements /// </summary> /// <param name="match"><see cref="MatchNode"/> for matching log items</param> /// <param name="parser"><see cref="IParser"/> for parsing log items</param> /// <param name="filter">An <see cref="Expression"/> for filtering log items</param> /// <param name="grouping">An enumerable of tuples of group names and grouping <see cref="Expression"/>s for grouping the log items</param> /// <param name="selects">An enumerable of tuples of projection labels and <see cref="Expression"/>s for projecting log items</param> /// <param name="order">An enumerable of tuples indicating sorting fields and sort order</param> /// <param name="limit">The number of items to return</param> /// <returns>A query tree for executing the query</returns> private static Node CreateQueryTree( MatchNode match, IOption <Tuple <string, IParser> > parser, IOption <Expression> filter, IOption <IEnumerable <Tuple <string, Expression> > > grouping, IOption <IEnumerable <Tuple <string, IAggregate> > > selects, IOption <IEnumerable <Tuple <string, bool> > > order, IOption <int> limit) { Node query = match; if (!parser.IsEmpty) { query = new ParseNode(query, parser.Get().Item2, parser.Get().Item1); } if (!filter.IsEmpty) { query = new PredicateNode(query, filter.Get()); } if (!grouping.IsEmpty) { var keyNames = grouping.Get().Select(g => g.Item1).ToArray(); var keyExpressions = grouping.Get().Select(g => g.Item2).ToArray(); if (selects.IsEmpty) { query = new GroupByNode(query, keyNames, keyExpressions, new string[0], new IAggregate[0]); } else { var aggregateNames = selects.Get().Select(s => s.Item1).ToArray(); var aggregates = selects.Get().Select(s => s.Item2).ToArray(); query = new GroupByNode(query, keyNames, keyExpressions, aggregateNames, aggregates); } } else if (!selects.IsEmpty) { var aggregateNames = selects.Get().Select(s => s.Item1).ToArray(); var aggregates = selects.Get().Select(s => s.Item2).ToArray(); if (aggregates.All(a => a is ListAggregate)) { query = new ProjectNode(query, aggregateNames, aggregates.Cast <ListAggregate>().Select(a => a.Expression).ToArray()); } else { query = new AggregateNode(query, aggregateNames, aggregates); } } if (!order.IsEmpty) { query = new OrderByNode(query, order.Get().Select(a => a.Item1).ToArray(), order.Get().Select(a => a.Item2).ToArray()); } if (!limit.IsEmpty) { query = new LimitNode(query, limit.Get()); } return(query); }
public DetailedQueryNode(SelectNode select, FromNode from, WhereNode where, GroupByNode groupBy, OrderByNode orderBy, SkipNode skip, TakeNode take, string returnVariableName) : base(select, from, where, groupBy, orderBy, skip, take) { ReturnVariableName = returnVariableName; }
public void Visit(GroupByNode node) { }
public void Visit(GroupByNode node) => Format(node, $"{string.Join(",", node.GroupNames)}|{string.Join(",", node.AggregateNames)}");
public void Visit(GroupByNode node) { node.Inner[0].Accept(this); Items = Items.Aggregate(() => new Dictionary <GroupKey, object[]>(), Update, Join, Complete).AsParallel().AsOrdered(); Dictionary <GroupKey, object[]> Update(Dictionary <GroupKey, object[]> state, LogItem item) { // calculate the key for the item var key = new GroupKey(item, node.GroupFunctions.Select(k => k(item)).ToArray()); // find the group for the item object[] group; if (!state.TryGetValue(key, out group)) { group = node.Aggregates.Select(a => a.Initialize()).ToArray(); state[key] = group; } // update the group with the item for (var n = 0; n < node.Aggregates.Length; n++) { group[n] = node.Aggregates[n].Update(group[n], item); } return(state); } Dictionary <GroupKey, object[]> Join(Dictionary <GroupKey, object[]> a, Dictionary <GroupKey, object[]> b) { foreach (var group in b) { if (a.ContainsKey(group.Key)) { a[group.Key] = node.Aggregates.Select((x, i) => x.Join(a[group.Key][i], group.Value[i])).ToArray(); } else { a[group.Key] = group.Value; } } return(a); } IEnumerable <LogItem> Complete(Dictionary <GroupKey, object[]> state) { foreach (var key in state.Keys) { // create a new item and populate it using the group key var item = new LogItem(string.Empty, key.Anchor.File, key.Anchor.Member, key.Anchor.Position, key.Anchor.Line); for (var n = 0; n < node.GroupNames.Length; n++) { item.Fields[node.GroupNames[n]] = key.Values[n]; } // complete all aggregates for the group and add them to the group var aggregates = node.Aggregates.Select((a, i) => a.Complete(state[key][i]).ToList()).ToList(); for (var n = 0; n < node.Aggregates.Length; n++) { if (aggregates[n].Count > 1) { item.Fields[node.AggregateNames[n]] = string.Join("\n", aggregates[n]); } else { item.Fields[node.AggregateNames[n]] = aggregates[n].FirstOrDefault(); } } yield return(item); } } }
public void Visit(GroupByNode node) { node.Inner[0].Accept(this); Tree = new GroupByNode(Tree, node.GroupNames, node.GroupExpressions, node.AggregateNames, node.Aggregates); }