public static ExprEvaluator GetMethodAggregationEvaluatorCountBy(ExprNode[] childNodes, bool join,
EventType[] typesPerStream)
{
if (childNodes[0] is ExprWildcard && childNodes.Length == 2)
return ExprMethodAggUtil.GetDefaultEvaluator(new[] {childNodes[1]}, join, typesPerStream);
if (childNodes[0] is ExprWildcard && childNodes.Length == 1)
return ExprMethodAggUtil.GetDefaultEvaluator(new ExprNode[0], join, typesPerStream);
return ExprMethodAggUtil.GetDefaultEvaluator(childNodes, join, typesPerStream);
}
private static ExprForge[] GetMethodAggregationEvaluatorCountByForge(
ExprNode[] childNodes,
bool join,
EventType[] typesPerStream)
{
if (childNodes[0] is ExprWildcard && childNodes.Length == 2) {
return ExprMethodAggUtil.GetDefaultForges(new[] {childNodes[1]}, join, typesPerStream);
}
if (childNodes[0] is ExprWildcard && childNodes.Length == 1) {
return ExprNodeUtilityQuery.EMPTY_FORGE_ARRAY;
}
return ExprMethodAggUtil.GetDefaultForges(childNodes, join, typesPerStream);
}
public override ExprForge[] GetMethodAggregationForge(
bool join,
EventType[] typesPerStream)
{
return(ExprMethodAggUtil.GetDefaultForges(parent.PositionalParams, join, typesPerStream));
}
public ExprEvaluator GetMethodAggregationEvaluator(bool join, EventType[] typesPerStream)
{
return ExprMethodAggUtil.GetDefaultEvaluator(_parent.PositionalParams, join, typesPerStream);
}
/// <summary>
/// Produces an aggregation service for use with match-recognice.
/// </summary>
/// <param name="numStreams">number of streams</param>
/// <param name="measureExprNodesPerStream">measure nodes</param>
/// <param name="typesPerStream">The types per stream.</param>
/// <returns>
/// service
/// </returns>
public static AggregationServiceMatchRecognizeFactoryDesc GetServiceMatchRecognize(
int numStreams,
IDictionary <int, IList <ExprAggregateNode> > measureExprNodesPerStream,
EventType[] typesPerStream)
{
var equivalencyListPerStream = new SortedDictionary <int, IList <AggregationServiceAggExpressionDesc> >();
foreach (var entry in measureExprNodesPerStream)
{
IList <AggregationServiceAggExpressionDesc> equivalencyList = new List <AggregationServiceAggExpressionDesc>();
equivalencyListPerStream.Put(entry.Key, equivalencyList);
foreach (var selectAggNode in entry.Value)
{
AddEquivalent(selectAggNode, equivalencyList);
}
}
var aggregatorsPerStream = new LinkedHashMap <int, AggregationMethodFactory[]>();
var evaluatorsPerStream = new Dictionary <int, ExprEvaluator[]>();
foreach (var equivalencyPerStream in equivalencyListPerStream)
{
var index = 0;
int stream = equivalencyPerStream.Key;
var aggregators = new AggregationMethodFactory[equivalencyPerStream.Value.Count];
aggregatorsPerStream.Put(stream, aggregators);
var evaluators = new ExprEvaluator[equivalencyPerStream.Value.Count];
evaluatorsPerStream.Put(stream, evaluators);
foreach (var aggregation in equivalencyPerStream.Value)
{
var aggregateNode = aggregation.AggregationNode;
if (aggregateNode.ChildNodes.Length > 1)
{
evaluators[index] = ExprMethodAggUtil.GetMultiNodeEvaluator(aggregateNode.ChildNodes, typesPerStream.Length > 1, typesPerStream);
}
else if (aggregateNode.ChildNodes.Length > 0)
{
// Use the evaluation node under the aggregation node to obtain the aggregation value
evaluators[index] = aggregateNode.ChildNodes[0].ExprEvaluator;
}
// For aggregation that doesn't evaluate any particular sub-expression, return null on evaluation
else
{
evaluators[index] = new ProxyExprEvaluator
{
ProcEvaluate = args => null,
ProcReturnType = () => null
};
}
aggregators[index] = aggregateNode.Factory;
index++;
}
}
// Assign a column number to each aggregation node. The regular aggregation goes first followed by access-aggregation.
var columnNumber = 0;
IList <AggregationServiceAggExpressionDesc> allExpressions = new List <AggregationServiceAggExpressionDesc>();
foreach (var equivalencyPerStream in equivalencyListPerStream)
{
foreach (var entry in equivalencyPerStream.Value)
{
entry.ColumnNum = columnNumber++;
}
allExpressions.AddAll(equivalencyPerStream.Value);
}
AggregationServiceMatchRecognizeFactory factory = new AggregationServiceMatchRecognizeFactoryImpl(numStreams, aggregatorsPerStream, evaluatorsPerStream);
return(new AggregationServiceMatchRecognizeFactoryDesc(factory, allExpressions));
}
