public static void ProcessChainable(
EsperEPL2GrammarParser.ChainableContext ctx,
IDictionary <ITree, ExprNode> astExprNodeMap,
ContextCompileTimeDescriptor contextCompileTimeDescriptor,
StatementSpecMapEnv mapEnv,
StatementSpecRaw statementSpec,
ExpressionDeclDesc expressionDeclarations,
LazyAllocatedMap <HashableMultiKey, AggregationMultiFunctionForge> plugInAggregations,
IList <ExpressionScriptProvided> scriptExpressions)
{
// we first convert the event property into chain spec
IList <Chainable> chain = ASTChainSpecHelper.GetChainables(ctx, astExprNodeMap);
// process chain
StatementSpecMapContext mapContext = new StatementSpecMapContext(contextCompileTimeDescriptor, mapEnv, plugInAggregations, scriptExpressions);
mapContext.AddExpressionDeclarations(expressionDeclarations);
ExprNode node = ChainableWalkHelper.ProcessDot(false, true, chain, mapContext);
astExprNodeMap.Put(ctx, node);
mapContext.AddTo(statementSpec);
}
private static ContextSpec WalkChoice(
EsperEPL2GrammarParser.CreateContextChoiceContext ctx,
IDictionary<ITree, ExprNode> astExprNodeMap,
IDictionary<ITree, EvalForgeNode> astPatternNodeMap,
PropertyEvalSpec propertyEvalSpec)
{
// temporal fixed (start+end) and overlapping (initiated/terminated)
if (ctx.START() != null || ctx.INITIATED() != null)
{
ExprNode[] distinctExpressions = null;
if (ctx.createContextDistinct() != null)
{
if (ctx.createContextDistinct().expressionList() == null)
{
distinctExpressions = ExprNodeUtilityQuery.EMPTY_EXPR_ARRAY;
}
else
{
distinctExpressions = ASTExprHelper.ExprCollectSubNodesPerNode(
ctx.createContextDistinct().expressionList().expression(), astExprNodeMap);
}
}
ContextSpecCondition startEndpoint;
if (ctx.START() != null)
{
var immediate = CheckNow(ctx.i);
if (immediate)
{
startEndpoint = ContextSpecConditionImmediate.INSTANCE;
}
else
{
startEndpoint = GetContextCondition(ctx.r1, astExprNodeMap, astPatternNodeMap, propertyEvalSpec, false);
}
}
else
{
var immediate = CheckNow(ctx.i);
startEndpoint = GetContextCondition(ctx.r1, astExprNodeMap, astPatternNodeMap, propertyEvalSpec, immediate);
}
var overlapping = ctx.INITIATED() != null;
var endEndpoint = GetContextCondition(ctx.r2, astExprNodeMap, astPatternNodeMap, propertyEvalSpec, false);
return new ContextSpecInitiatedTerminated(startEndpoint, endEndpoint, overlapping, distinctExpressions);
}
// partitioned
if (ctx.PARTITION() != null)
{
IList<EsperEPL2GrammarParser.CreateContextPartitionItemContext> partitions = ctx.createContextPartitionItem();
IList<ContextSpecKeyedItem> rawSpecs = new List<ContextSpecKeyedItem>();
foreach (var partition in partitions)
{
var filterSpec = ASTFilterSpecHelper.WalkFilterSpec(partition.eventFilterExpression(), propertyEvalSpec, astExprNodeMap);
propertyEvalSpec = null;
IList<string> propertyNames = new List<string>();
IList<EsperEPL2GrammarParser.ChainableContext> properties = partition.chainable();
foreach (var property in properties)
{
var propertyName = ASTUtil.GetPropertyName(property, 0);
propertyNames.Add(propertyName);
}
ASTExprHelper.ExprCollectSubNodes(partition, 0, astExprNodeMap); // remove expressions
rawSpecs.Add(
new ContextSpecKeyedItem(
filterSpec, propertyNames, partition.keywordAllowedIdent() == null ? null : partition.keywordAllowedIdent().GetText()));
}
IList<ContextSpecConditionFilter> optionalInit = null;
if (ctx.createContextPartitionInit() != null)
{
optionalInit = GetContextPartitionInit(ctx.createContextPartitionInit().createContextFilter(), astExprNodeMap);
}
ContextSpecCondition optionalTermination = null;
if (ctx.createContextPartitionTerm() != null)
{
optionalTermination = GetContextCondition(
ctx.createContextPartitionTerm().createContextRangePoint(), astExprNodeMap, astPatternNodeMap, propertyEvalSpec, false);
}
return new ContextSpecKeyed(rawSpecs, optionalInit, optionalTermination);
}
if (ctx.COALESCE() != null)
{
// hash
IList<EsperEPL2GrammarParser.CreateContextCoalesceItemContext> coalesces = ctx.createContextCoalesceItem();
IList<ContextSpecHashItem> rawSpecs = new List<ContextSpecHashItem>(coalesces.Count);
foreach (var coalesce in coalesces)
{
var chain = ASTChainSpecHelper.GetChainables(coalesce.chainable(), astExprNodeMap);
var func = chain[0];
var filterSpec = ASTFilterSpecHelper.WalkFilterSpec(coalesce.eventFilterExpression(), propertyEvalSpec, astExprNodeMap);
propertyEvalSpec = null;
rawSpecs.Add(new ContextSpecHashItem(func, filterSpec));
}
var granularity = ctx.g.Text;
if (!granularity.ToLowerInvariant().Equals("granularity"))
{
throw ASTWalkException.From("Expected 'granularity' keyword after list of coalesce items, found '" + granularity + "' instead");
}
var num = ASTConstantHelper.Parse(ctx.number());
var preallocateStr = ctx.p?.Text;
if (preallocateStr != null && !preallocateStr.ToLowerInvariant().Equals("preallocate"))
{
throw ASTWalkException.From(
"Expected 'preallocate' keyword after list of coalesce items, found '" + preallocateStr + "' instead");
}
if (!num.GetType().IsNumericNonFP() || num.GetType().GetBoxedType() == typeof(long?))
{
throw ASTWalkException.From("Granularity provided must be an int-type number, received " + num.GetType() + " instead");
}
return new ContextSpecHash(rawSpecs, num.AsInt32(), preallocateStr != null);
}
// categorized
if (ctx.createContextGroupItem() != null)
{
IList<EsperEPL2GrammarParser.CreateContextGroupItemContext> grps = ctx.createContextGroupItem();
IList<ContextSpecCategoryItem> items = new List<ContextSpecCategoryItem>();
foreach (var grp in grps)
{
var exprNode = ASTExprHelper.ExprCollectSubNodes(grp, 0, astExprNodeMap)[0];
var name = grp.i.Text;
items.Add(new ContextSpecCategoryItem(exprNode, name));
}
var filterSpec = ASTFilterSpecHelper.WalkFilterSpec(ctx.eventFilterExpression(), propertyEvalSpec, astExprNodeMap);
return new ContextSpecCategory(items, filterSpec);
}
throw new IllegalStateException("Unrecognized context detail type");
}