public AggregateNode Build()
{
IBindingMetadata metadata = this.Schema.GetMetadata <IBindingMetadata>();
AggregateNode aggrNode = new AggregateNode()
{
Metadata = metadata,
Index = this.State.Indexer.GetListIndex(metadata.Item.Identity),
};
if (this.State.Aggregate.Targets.Count > 0)
{
aggrNode.Item = new MetadataNode(metadata.Item);
}
foreach (MetadataIdentity identity in this.State.Aggregate.Targets)
{
IBindingMetadata targetMetadata = identity.GetMetadata <IBindingMetadata>();
IBindingMetadata valueMetadata = targetMetadata.HasFlag(BindingMetadataFlags.Item) ? targetMetadata.Parent : targetMetadata;
MetadataNode valueNode = new MetadataNode(valueMetadata)
{
ListIndex = this.State.Indexer.GetListIndex(identity),
};
this.AddListNode(aggrNode, valueNode);
}
return(aggrNode);
}
public static void Validate(AggregateNode aggregateNode)
{
if (aggregateNode.Item == null)
{
return;
}
foreach (MetadataNode node in aggregateNode.Item.Tree().Skip(1))
{
if (!node.Metadata.HasFlag(BindingMetadataFlags.Writable))
{
throw BindingException.FromProperty(node.Identity.Name, $"Property is read-only.");
}
if (node.ListIndex == null)
{
ValidateConstructor(node);
}
if (node.ListIndex == null && node.HasFlag(NodeFlags.Dynamic))
{
ValidateDynamic(node);
}
}
}
internal static ReteNode Create(AggregateNode node)
{
var values = new[] { new KeyValuePair <string, object>("Name", node.Name) };
var expressions = node.Expressions.Select(e =>
new KeyValuePair <string, LambdaExpression>(e.Name, e.Expression));
return(new ReteNode(node.Id, NodeType.Aggregate, outputType: node.NodeInfo.OutputType,
values: values, expressions: expressions, rules: node.NodeInfo.Rules));
}
protected internal override void VisitAggregateNode(SchemaBuilder builder, AggregateNode node)
{
if (builder.IsVisited(node))
{
return;
}
builder.AddNode(node, ReteNode.Create);
base.VisitAggregateNode(builder, node);
}
protected internal override void VisitAggregateNode(SnapshotBuilder builder, AggregateNode node)
{
if (builder.IsVisited(node))
{
return;
}
builder.AddNode(node, NodeInfo.Create);
base.VisitAggregateNode(builder, node);
}
public void Visit(AggregateNode node)
{
node.Inner[0].Accept(this);
Items = Items.Aggregate(() => node.Aggregates.Select(a => a.Initialize()).ToArray(), Update, Join, Complete).AsParallel().AsOrdered();
object[] Update(object[] state, LogItem item)
{
for (var n = 0; n < node.Aggregates.Length; n++)
{
state[n] = node.Aggregates[n].Update(state[n], item);
}
return(state);
}
object[] Join(object[] a, object[] b)
{
for (var n = 0; n < node.Aggregates.Length; n++)
{
a[n] = node.Aggregates[n].Join(a[n], b[n]);
}
return(a);
}
IEnumerable <LogItem> Complete(object[] state)
{
var aggregates = node.Aggregates.Select((a, i) => a.Complete(state[i]).GetEnumerator()).ToArray();
var hasNext = aggregates.Select(a => a.MoveNext()).ToArray();
while (hasNext.Any(a => a))
{
var item = new LogItem(string.Empty, string.Empty, string.Empty, 0, 0);
for (var n = 0; n < aggregates.Length; n++)
{
if (hasNext[n])
{
item.Fields[node.Names[n]] = aggregates[n].Current;
}
else
{
item.Fields[node.Names[n]] = null;
}
hasNext[n] = aggregates[n].MoveNext();
}
yield return(item);
}
}
}
public override Node visitSubtract(JuliarParser.SubtractContext ctx)
{
string text = ctx.subtraction().Text;
if ("subtract".Equals(text) || "-".Equals(text))
{
if (ctx.types().size() == 2)
{
BinaryNode node = new BinaryNode();
try
{
/*
* Node n = node.makeNode(
* Operation.subtract,
* ctx.types(0).accept(this),
* ctx.types(1).accept(this));
* n.addInst( funcContextStack, n);
*/
}
catch (Exception ex)
{
JuliarLogger.log(ex.Message, ex);
}
}
if (ctx.types().size() > 2)
{
IList <IntegralTypeNode> data = new List <IntegralTypeNode>();
for (int i = 0; i < ctx.types().size(); i++)
{
data.Add((IntegralTypeNode)ctx.types(i).accept(this));
}
AggregateNode aggregateNode = new AggregateNode(Operation.subtract, data);
FunctionDeclNode functionDeclNode = (FunctionDeclNode)funcContextStack.Peek();
functionDeclNode.addInst(aggregateNode);
}
}
return(null);
}
private void AddListNode(AggregateNode aggrNode, MetadataNode node)
{
MetadataNode parentNode = aggrNode.Item.FindNode(node.Metadata.Parent);
MetadataNode thisNode = aggrNode.Item.FindNode(node.Metadata);
if (thisNode == null && parentNode != null)
{
parentNode.Properties.Add(node);
}
else if (parentNode == null)
{
MetadataNode newParent = new MetadataNode(node.Metadata.Parent)
{
Metadata = node.Metadata.Parent,
};
newParent.Properties.Add(node);
this.AddListNode(aggrNode, newParent);
}
}
public Action <ExpandingArray, ExpandingArray <bool> > CompileAggregate()
{
this.variables = new VariableStore();
AggregateBuilder builder = new AggregateBuilder(this.State);
AggregateNode aggregateNode = builder.Build();
ContractValidator.Validate(aggregateNode);
List <Expression> body = new List <Expression>();
this.AddAggregateValue(aggregateNode, body);
var block = this.variables.ToBlock(body);
var lambda = Expression.Lambda <Action <ExpandingArray, ExpandingArray <bool>, Type> >(block, ResultArgs.Lists,
ResultArgs.Bits,
ResultArgs.SchemaType);
var func = lambda.Compile();
Type schemaType = this.State.Schema.Model;
return((lists, bits) => func(lists, bits, schemaType));
}
public void Visit(AggregateNode node)
{
node.Inner[0].Accept(this);
Mode = Query.EvaluationMode.Aggregate;
}
protected internal virtual void VisitAggregateNode(TContext context, AggregateNode node)
{
VisitBetaNode(context, node);
}
/// <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 AggregateTable(AggregateNode node, Program program) : base(node, program)
{
}
internal static NodeInfo Create(AggregateNode node)
{
return(new NodeInfo(NodeType.Aggregate, string.Empty));
}
protected override bool IsAggregate(string nodeName)
{
return(AggregateNode.IsAggregate(nodeName));
}
public void Visit(AggregateNode node)
{
node.Inner[0].Accept(this);
Tree = new AggregateNode(Tree, node.Names, node.Aggregates);
}
internal static NodeInfo Create(AggregateNode node)
{
var expressions = node.ExpressionMap.Select(e => string.Format("{0}={1}", e.Name, e.Expression.ToString()));
return(new NodeInfo(NodeType.Aggregate, node.Name, Empty, expressions, Empty));
}
public void Init(ParsingContext context, ParseTreeNode parseNode)
{
if (parseNode.ChildNodes[0].Token != null)
{
if (parseNode.ChildNodes[0].Token.Text == SonesGQLConstants.ASTERISKSYMBOL)
{
SelType = TypesOfSelect.Asterisk;
}
else
{
throw new NotImplementedQLException(parseNode.ChildNodes[0].Token.Text);
}
}
else if (parseNode.ChildNodes[0].AstNode is SelByTypeNode)
{
TypeName = ((SelByTypeNode)parseNode.ChildNodes[0].AstNode).TypeName;
}
else
{
#region IDNode or AggregateNode
SelType = TypesOfSelect.None;
object astNode = parseNode.ChildNodes[0].AstNode;
if (astNode == null)
{
// why the hack are functions without a caller in the child/child?
if ((parseNode.ChildNodes[0].ChildNodes != null && parseNode.ChildNodes[0].ChildNodes.Count > 0) && parseNode.ChildNodes[0].ChildNodes[0].AstNode != null)
{
astNode = parseNode.ChildNodes[0].ChildNodes[0].AstNode;
}
else
{
if (parseNode.ChildNodes[0].ChildNodes != null && parseNode.ChildNodes[0].ChildNodes.Count > 0)
{
throw new ArgumentException("This is not a valid IDNode: " + (parseNode.ChildNodes[0].ChildNodes.Aggregate("", (result, elem) => { result += elem.Token.Text + "."; return(result); })));
}
else
{
throw new ArgumentException("Found an invalid IDNode");
}
}
}
if (astNode is IDNode)
{
IDNode aIDNode = astNode as IDNode;
#region ID
TypeOfColumnSource = TypesOfColumnSource.ID;
#region get value
ColumnSourceValue = ((IDNode)aIDNode).IDChainDefinition;
#endregion
#region Alias handling
if (HasChildNodes(parseNode.ChildNodes[1])) // && parseNode.ChildNodes.Last().AstNode is AliasNode)
{
AliasId = parseNode.ChildNodes[1].ChildNodes[1].Token.ValueString; //(parseNode.ChildNodes.Last().AstNode as AliasNode).AliasId;
}
#endregion
#endregion
}
else if (astNode is AggregateNode)
{
#region aggregate
TypeOfColumnSource = TypesOfColumnSource.Aggregate;
AggregateNode aAggregateNode = (AggregateNode)astNode;
ColumnSourceValue = aAggregateNode.AggregateDefinition;
#endregion
#region Alias handling
if (HasChildNodes(parseNode.ChildNodes[1])) //Last().AstNode is AliasNode)
{
AliasId = parseNode.ChildNodes[1].ChildNodes[1].Token.ValueString; //(parseNode.ChildNodes.Last().AstNode as AliasNode).AliasId;
}
else
{
AliasId = aAggregateNode.FuncDefinition.SourceParsedString;
}
#endregion
}
else
{
throw new NotImplementedQLException(parseNode.ChildNodes[0].AstNode.GetType().Name);
}
#endregion
}
}
public void Visit(AggregateNode node) => Format(node, $"{string.Join(",", node.Names)}");
protected internal virtual void VisitAggregateNode(TContext builder, AggregateNode node)
{
VisitBetaNode(builder, node);
}
internal static NodeInfo Create(AggregateNode node)
{
var expressions = node.ExpressionMap.Select(e => string.Format("{0}={1}", e.Name, e.Expression.ToString()));
return new NodeInfo(NodeType.Aggregate, node.Name, Empty, expressions, Empty);
}
public void Visit(AggregateNode node)
{
Fields = node.Names.Select((n, i) => new { name = n, type = node.Types[i] }).ToDictionary(n => n.name, n => n.type);
}
public DirectAggregateReferenceViolation(Node node, AggregateNode referencedAggregate)
{
Node = node;
ReferencedAggregate = referencedAggregate;
}
internal static NodeInfo Create(AggregateNode node)
{
var expressions = node.ExpressionMap.Select(e => $"{e.Name}={e.Expression.ToString()}");
return(new NodeInfo(NodeType.Aggregate, node.Name, Empty, expressions, Empty));
}
public void Visit(AggregateNode node) => VisitInternal(node);
