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