internal static IList<FilterSpecParam>[] PlanFilterParameters(
IList<ExprNode> validatedNodes,
FilterSpecCompilerArgs args)
{
if (validatedNodes.IsEmpty())
{
return AllocateListArray(0);
}
var filterParamExprMap = new FilterParamExprMap();
// Make filter parameter for each expression node, if it can be optimized
DecomposePopulateConsolidate(filterParamExprMap, validatedNodes, args);
// Use all filter parameter and unassigned expressions
IList<FilterSpecParam> filterParams = new List<FilterSpecParam>();
filterParams.AddAll(filterParamExprMap.FilterParams);
int countUnassigned = filterParamExprMap.CountUnassignedExpressions();
// we are done if there are no remaining nodes
if (countUnassigned == 0)
{
return AllocateListArraySizeOne(filterParams);
}
// determine max-width
int filterServiceMaxFilterWidth =
args.ConfigurationInformation.EngineDefaults.ExecutionConfig.FilterServiceMaxFilterWidth;
HintAttribute hint = HintEnum.MAX_FILTER_WIDTH.GetHint(args.Annotations);
if (hint != null)
{
string hintValue = HintEnum.MAX_FILTER_WIDTH.GetHintAssignedValue(hint);
filterServiceMaxFilterWidth = int.Parse(hintValue);
}
IList<FilterSpecParam>[] plan = null;
if (filterServiceMaxFilterWidth > 0)
{
plan = PlanRemainingNodesIfFeasible(filterParamExprMap, args, filterServiceMaxFilterWidth);
}
if (plan != null)
{
return plan;
}
// handle no-plan
FilterSpecParamExprNode node = MakeRemainingNode(filterParamExprMap.UnassignedExpressions, args);
filterParams.Add(node);
return AllocateListArraySizeOne(filterParams);
}
public ExprNodeAdapterBase Make(
FilterSpecParamExprNode node,
EventBean[] events,
ExprEvaluatorContext exprEvaluatorContext,
StatementContext statementContext,
int agentInstanceId)
{
int filterSpecId = node.FilterSpecId;
int filterSpecParamPathNum = node.FilterSpecParamPathNum;
ExprNode exprNode = node.ExprNode;
VariableService variableService = node.VariableService;
// handle table evaluator context
if (node.HasTableAccess)
{
exprEvaluatorContext = new ExprEvaluatorContextWTableAccess(exprEvaluatorContext, node.TableService);
}
// non-pattern case
ExprNodeAdapterBase adapter;
if (events == null)
{
// if a subquery is present in a filter stream acquire the agent instance lock
if (node.HasFilterStreamSubquery)
{
adapter = GetLockableSingle(
filterSpecId, filterSpecParamPathNum, exprNode, exprEvaluatorContext, variableService,
statementContext, agentInstanceId);
}
// no-variable no-prior event evaluation
else if (!node.HasVariable)
{
adapter = new ExprNodeAdapterBase(
filterSpecId, filterSpecParamPathNum, exprNode, exprEvaluatorContext);
}
else
{
// with-variable no-prior event evaluation
adapter = new ExprNodeAdapterBaseVariables(
filterSpecId, filterSpecParamPathNum, exprNode, exprEvaluatorContext, variableService);
}
}
else
{
// pattern cases
VariableService variableServiceToUse = node.HasVariable ? variableService : null;
if (node.UseLargeThreadingProfile)
{
// no-threadlocal evaluation
// if a subquery is present in a pattern filter acquire the agent instance lock
if (node.HasFilterStreamSubquery)
{
adapter = GetLockableMultiStreamNoTL(
filterSpecId, filterSpecParamPathNum, exprNode, exprEvaluatorContext, variableServiceToUse,
events);
}
else
{
adapter = new ExprNodeAdapterMultiStreamNoTL(
filterSpecId, filterSpecParamPathNum, exprNode, exprEvaluatorContext, variableServiceToUse,
events);
}
}
else
{
if (node.HasFilterStreamSubquery)
{
adapter = GetLockableMultiStream(
filterSpecId, filterSpecParamPathNum, exprNode, exprEvaluatorContext, variableServiceToUse,
events);
}
else
{
// evaluation with threadlocal cache
adapter = new ExprNodeAdapterMultiStream(
filterSpecId, filterSpecParamPathNum, exprNode, exprEvaluatorContext, variableServiceToUse,
events);
}
}
}
if (!node.HasTableAccess)
{
return adapter;
}
// handle table
return new ExprNodeAdapterBaseWTableAccess(
filterSpecId, filterSpecParamPathNum, exprNode, exprEvaluatorContext, adapter, node.TableService);
}
