Instrumentation (Esper API Documentation)

All Known Implementing Classes:

InstrumentationDefault
```
public interface Instrumentation
```

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`void`	`aAggAccessEnterLeave(boolean enter, int index, AggregationState state)`
`void`	`aAggNoAccessEnterLeave(boolean enter, int index, AggregationMethod aggregationMethod)`
`void`	`aAggregationGroupedApplyEnterLeave(boolean enter)`
`void`	`aAggregationGroupedRollupEvalParam(Object result)`
`void`	`aAggregationUngroupedApplyEnterLeave(boolean enter)`
`void`	`aContextPartitionAllocate()`
`void`	`aContextPartitionDestroy()`
`void`	`aContextScheduledEval()`
`void`	`aEngineManagementStmtCompileStart(boolean success, String message)`
`void`	`aEngineManagementStmtStop()`
`void`	`aEvent()`
`void`	`aEventCP()`
`void`	`aExprAnd(Boolean result)`
`void`	`aExprArray(Object result)`
`void`	`aExprBetween(Boolean result)`
`void`	`aExprBitwise(Object result)`
`void`	`aExprBool(Boolean result)`
`void`	`aExprCase(Object result)`
`void`	`aExprCast(Object result)`
`void`	`aExprCoalesce(Object value)`
`void`	`aExprConcat(String result)`
`void`	`aExprContextProp(Object result)`
`void`	`aExprDeclared(Object value)`
`void`	`aExprDot(Object result)`
`void`	`aExprDotChain()`
`void`	`aExprDotChainElement(EPType typeInfo, Object result)`
`void`	`aExprEquals(Boolean result)`
`void`	`aExprEqualsAnyOrAll(Boolean result)`
`void`	`aExprIdent(Object result)`
`void`	`aExprIn(Boolean result)`
`void`	`aExprInstanceof(Boolean result)`
`void`	`aExprIs(boolean result)`
`void`	`aExprLike(Boolean result)`
`void`	`aExprMath(Object result)`
`void`	`aExprMinMaxRow(Object result)`
`void`	`aExprNew(Map<String,Object> props)`
`void`	`aExprNot(Boolean result)`
`void`	`aExprOr(Boolean result)`
`void`	`aExprPlugInSingleRow(Object result)`
`void`	`aExprPrev(Object result)`
`void`	`aExprPrior(Object result)`
`void`	`aExprPropExists(boolean exists)`
`void`	`aExprRegexp(Boolean result)`
`void`	`aExprRelOp(Boolean result)`
`void`	`aExprRelOpAnyOrAll(Boolean result)`
`void`	`aExprStreamEventMethod(Object result)`
`void`	`aExprStreamUnd(Object result)`
`void`	`aExprStreamUndMethod(Object result)`
`void`	`aExprStreamUndSelectClause(EventBean event)`
`void`	`aExprSubselect(Object result)`
`void`	`aExprTableSubpropAccessor(Object result)`
`void`	`aExprTableSubproperty(Object result)`
`void`	`aExprTableTop(Object result)`
`void`	`aExprTimePeriod(Object result)`
`void`	`aExprTypeof(String typeName)`
`void`	`aExprValue(Object result)`
`void`	`aExprVariable(Object value)`
`void`	`aFilter(Collection<FilterHandle> matches)`
`void`	`aFilterActivationNamedWindowInsert()`
`void`	`aFilterActivationOnTrigger()`
`void`	`aFilterActivationStream()`
`void`	`aFilterActivationSubselect()`
`void`	`aFilterAdd()`
`void`	`aFilterBoolean()`
`void`	`aFilterBooleanExpr(boolean result)`
`void`	`aFilterHandleSetIndexes()`
`void`	`aFilterRemove()`
`void`	`aFilterReverseIndex(Boolean match)`
`void`	`aHavingClauseJoin(Boolean pass)`
`void`	`aHavingClauseNonJoin(Boolean pass)`
`void`	`aHistoricalScheduledEval()`
`void`	`aIndexAdd()`
`void`	`aIndexAddRemove()`
`void`	`aIndexJoinLookup(Set<EventBean> result, Object keys)`
`void`	`aIndexRemove()`
`void`	`aIndexSubordLookup(Collection<EventBean> events, Object keys)`
`void`	`aInfraMergeWhenThenActionItem(boolean applies)`
`void`	`aInfraMergeWhenThenActions()`
`void`	`aInfraMergeWhenThenItem(boolean matched, boolean actionsApplied)`
`void`	`aInfraMergeWhenThens(boolean matched)`
`void`	`aInfraOnAction()`
`void`	`aInfraTriggeredLookup(EventBean[] result)`
`void`	`aInfraUpdate(EventBean afterUpdate)`
`void`	`aInfraUpdateRHSExpr(Object result)`
`void`	`aJoinCompositionHistorical(Set<MultiKey<EventBean>> newResults, Set<MultiKey<EventBean>> oldResults)`
`void`	`aJoinCompositionQueryStrategy()`
`void`	`aJoinCompositionStepUpdIndex()`
`void`	`aJoinCompositionStreamToWin(Set<MultiKey<EventBean>> newResults)`
`void`	`aJoinCompositionWinToWin(Set<MultiKey<EventBean>> newResults, Set<MultiKey<EventBean>> oldResults)`
`void`	`aJoinDispatch()`
`void`	`aJoinExecFilter(Set<MultiKey<EventBean>> newEvents, Set<MultiKey<EventBean>> oldEvents)`
`void`	`aJoinExecProcess()`
`void`	`aJoinExecStrategy(UniformPair<Set<MultiKey<EventBean>>> joinSet)`
`void`	`aNamedWindowCPMulti()`
`void`	`aNamedWindowCPSingle()`
`void`	`aNamedWindowDispatch()`
`void`	`aOrderBy(Object values)`
`void`	`aOutputProcessNonBuffered()`
`void`	`aOutputProcessNonBufferedJoin()`
`void`	`aOutputProcessWCondition(boolean buffered)`
`void`	`aOutputProcessWConditionJoin(boolean buffered)`
`void`	`aOutputRateConditionOutputNow(boolean generate)`
`void`	`aOutputRateConditionScheduledEval()`
`void`	`aOutputRateConditionUpdate()`
`void`	`aPatternAndEvaluateFalse()`
`void`	`aPatternAndEvaluateTrue(boolean quitted)`
`void`	`aPatternAndQuit()`
`void`	`aPatternAndStart()`
`void`	`aPatternEveryDistinctEvalFalse()`
`void`	`aPatternEveryDistinctEvaluateTrue(Set<Object> keysFromNodeNoExpire, LinkedHashMap<Object,Long> keysFromNodeExpire, Object matchEventKey, boolean haveSeenThis)`
`void`	`aPatternEveryDistinctQuit()`
`void`	`aPatternEveryDistinctStart()`
`void`	`aPatternEveryEvalFalse()`
`void`	`aPatternEveryEvaluateTrue()`
`void`	`aPatternEveryQuit()`
`void`	`aPatternEveryStart()`
`void`	`aPatternFilterMatch(boolean quitted)`
`void`	`aPatternFilterQuit()`
`void`	`aPatternFilterStart()`
`void`	`aPatternFollowedByEvalFalse()`
`void`	`aPatternFollowedByEvaluateTrue(boolean quitted)`
`void`	`aPatternFollowedByQuit()`
`void`	`aPatternFollowedByStart()`
`void`	`aPatternGuardEvaluateTrue(boolean quitted)`
`void`	`aPatternGuardGuardQuit()`
`void`	`aPatternGuardQuit()`
`void`	`aPatternGuardScheduledEval()`
`void`	`aPatternGuardStart()`
`void`	`aPatternMatchUntilEvalFalse()`
`void`	`aPatternMatchUntilEvaluateTrue(boolean quitted)`
`void`	`aPatternMatchUntilQuit()`
`void`	`aPatternMatchUntilStart()`
`void`	`aPatternNotEvalFalse()`
`void`	`aPatternNotEvaluateTrue(boolean quitted)`
`void`	`aPatternNotQuit()`
`void`	`aPatternNotStart()`
`void`	`aPatternObserverEvaluateTrue()`
`void`	`aPatternObserverQuit()`
`void`	`aPatternObserverScheduledEval()`
`void`	`aPatternObserverStart()`
`void`	`aPatternOrEvalFalse()`
`void`	`aPatternOrEvaluateTrue(boolean quitted)`
`void`	`aPatternOrQuit()`
`void`	`aPatternOrStart()`
`void`	`aPatternRootEvalFalse()`
`void`	`aPatternRootEvaluateTrue(boolean quitted)`
`void`	`aPatternRootQuit()`
`void`	`aPatternRootStart()`
`void`	`aRegEx(RegexPartitionState partitionState, List<RegexNFAStateEntry> endStates, List<RegexNFAStateEntry> terminationStates)`
`void`	`aRegExPartition(boolean exists, RegexPartitionState state)`
`void`	`aRegExScheduledEval()`
`void`	`aRegExState(List<RegexNFAStateEntry> next, LinkedHashMap<String,Pair<Integer,Boolean>> variableStreams, int[] multimatchStreamNumToVariable)`
`void`	`aRegExStateStart(List<RegexNFAStateEntry> nextStates, LinkedHashMap<String,Pair<Integer,Boolean>> variableStreams, int[] multimatchStreamNumToVariable)`
`void`	`aRegIntervalState(boolean scheduled)`
`void`	`aRegIntervalValue(long result)`
`void`	`aRegMeasure(EventBean outBean)`
`void`	`aRegOut()`
`void`	`aResultSetProcessComputeGroupKeys(boolean enter, Object groupKeysPerEvent)`
`void`	`aResultSetProcessGroupedRowPerEvent(EventBean[] selectNewEvents, EventBean[] selectOldEvents)`
`void`	`aResultSetProcessGroupedRowPerGroup(EventBean[] selectNewEvents, EventBean[] selectOldEvents)`
`void`	`aResultSetProcessSimple(EventBean[] selectNewEvents, EventBean[] selectOldEvents)`
`void`	`aResultSetProcessUngroupedFullyAgg(EventBean[] selectNewEvents, EventBean[] selectOldEvents)`
`void`	`aResultSetProcessUngroupedNonfullyAgg(EventBean[] selectNewEvents, EventBean[] selectOldEvents)`
`void`	`aRouteBetweenStmt()`
`void`	`aScheduleAdd()`
`void`	`aScheduleEval(Collection<ScheduleHandle> handles)`
`void`	`aScheduleRemove()`
`void`	`aSelectClause(boolean newData, EventBean event, Object[] subscriberParameters)`
`void`	`aSplitStream(boolean all, boolean handled)`
`void`	`aSplitStreamRoute()`
`void`	`aSplitStreamWhere(Boolean pass)`
`void`	`aStimulantEvent()`
`void`	`aStimulantTime()`
`void`	`aSubselectAggregation()`
`void`	`aTableAddEvent()`
`void`	`aTableDeleteEvent()`
`void`	`aTime()`
`void`	`aTimeCP()`
`void`	`aUpdateIStream(EventBean finalEvent, boolean haveCloned)`
`void`	`aUpdateIStreamApply(EventBean updated, boolean applied)`
`void`	`aUpdateIStreamApplyAssignmentItem(Object value)`
`void`	`aUpdateIStreamApplyAssignments(Object[] values)`
`void`	`aUpdateIStreamApplyWhere(Boolean result)`
`void`	`aViewIndicate()`
`void`	`aViewProcessIRStream()`
`void`	`aViewScheduledEval()`
`void`	`aWhereClauseFilter(EventBean[] filteredNewData, EventBean[] filteredOldData)`
`void`	`aWhereClauseFilterEval(Boolean pass)`
`void`	`aWhereClauseIR()`
`void`	`qaEngineManagementStmtStarted(String engineURI, int statementId, String statementName, String epl, long engineTime)`
`void`	`qaExprAggValue(ExprAggregateNodeBase exprAggregateNodeBase, Object value)`
`void`	`qaExprConst(Object result)`
`void`	`qaExprIStream(ExprIStreamNode exprIStreamNode, boolean newData)`
`void`	`qaExprTimestamp(ExprTimestampNode exprTimestampNode, long value)`
`void`	`qaFilterHandleSetCallbacks(Set<FilterHandle> callbackSet)`
`void`	`qAggAccessEnterLeave(boolean enter, int index, AggregationState state, ExprNode aggExpr)`
`void`	`qAggNoAccessEnterLeave(boolean enter, int index, AggregationMethod aggregationMethod, ExprNode aggExpr)`
`void`	`qAggregationGroupedApplyEnterLeave(boolean enter, int numAggregators, int numAccessStates, Object groupKey)`
`void`	`qAggregationGroupedRollupEvalParam(boolean enter, int length)`
`void`	`qAggregationUngroupedApplyEnterLeave(boolean enter, int numAggregators, int numAccessStates)`
`void`	`qaStatementResultExecute(UniformPair<EventBean[]> events, int statementId, String statementName, int agentInstanceId, long threadId)`
`void`	`qaTableUpdatedEvent(EventBean theEvent)`
`void`	`qaTableUpdatedEventWKeyAfter(EventBean theEvent)`
`void`	`qaTableUpdatedEventWKeyBefore(EventBean theEvent)`
`void`	`qContextPartitionAllocate(AgentInstanceContext agentInstanceContext)`
`void`	`qContextPartitionDestroy(AgentInstanceContext agentInstanceContext)`
`void`	`qContextScheduledEval(ContextDescriptor contextDescriptor)`
`void`	`qEngineManagementStmtCompileStart(String engineURI, int statementId, String statementName, String epl, long engineTime)`
`void`	`qEngineManagementStmtStop(EPStatementState targetState, String engineURI, int statementId, String statementName, String epl, long engineTime)`
`void`	`qEvent(EventBean eventBean, String engineURI, boolean providedBySendEvent)`
`void`	`qEventCP(EventBean theEvent, EPStatementAgentInstanceHandle handle, long engineTime)`
`void`	`qExprAnd(ExprNode exprNode)`
`void`	`qExprArray(ExprArrayNode exprArrayNode)`
`void`	`qExprBetween(ExprBetweenNodeImpl exprBetweenNode)`
`void`	`qExprBitwise(ExprNode exprNode, BitWiseOpEnum bitWiseOpEnum)`
`void`	`qExprBool(ExprNode exprNode, EventBean[] eventsPerStream)`
`void`	`qExprCase(ExprCaseNode exprCaseNode)`
`void`	`qExprCast(ExprCastNode exprCastNode)`
`void`	`qExprCoalesce(ExprCoalesceNode exprCoalesceNode)`
`void`	`qExprConcat(ExprConcatNode exprConcatNode)`
`void`	`qExprContextProp(ExprContextPropertyNodeImpl exprContextPropertyNode)`
`void`	`qExprDeclared(ExpressionDeclItem parent)`
`void`	`qExprDot(ExprDotNode exprDotNode)`
`void`	`qExprDotChain(EPType targetTypeInfo, Object target, ExprDotEval[] evalUnpacking)`
`void`	`qExprDotChainElement(int num, ExprDotEval methodEval)`
`void`	`qExprEquals(ExprNode exprNode)`
`void`	`qExprEqualsAnyOrAll(ExprEqualsAllAnyNode exprEqualsAllAnyNode)`
`void`	`qExprIdent(String fullUnresolvedName)`
`void`	`qExprIn(ExprInNodeImpl exprInNode)`
`void`	`qExprInstanceof(ExprInstanceofNode exprInstanceofNode)`
`void`	`qExprIs(ExprEqualsNodeImpl exprNode)`
`void`	`qExprLike(ExprNode exprNode)`
`void`	`qExprMath(ExprMathNode exprMathNode, String op)`
`void`	`qExprMinMaxRow(ExprMinMaxRowNode exprMinMaxRowNode)`
`void`	`qExprNew(ExprNewStructNode exprNewNode)`
`void`	`qExprNot(ExprNotNode exprNotNode)`
`void`	`qExprOr(ExprOrNode exprOrNode)`
`void`	`qExprPlugInSingleRow(Method method)`
`void`	`qExprPrev(ExprPreviousNode exprPreviousNode, boolean newData)`
`void`	`qExprPrior(ExprPriorNode exprPriorNode)`
`void`	`qExprPropExists(ExprPropertyExistsNode exprPropertyExistsNode)`
`void`	`qExprRegexp(ExprRegexpNode exprRegexpNode)`
`void`	`qExprRelOp(ExprRelationalOpNodeImpl exprRelationalOpNode, String op)`
`void`	`qExprRelOpAnyOrAll(ExprRelationalOpAllAnyNode exprRelationalOpAllAnyNode, String op)`
`void`	`qExprStreamEventMethod(ExprDotNode exprDotNode)`
`void`	`qExprStreamUnd(ExprStreamUnderlyingNodeImpl exprStreamUnderlyingNode)`
`void`	`qExprStreamUndMethod(ExprDotNode exprDotEvalStreamMethod)`
`void`	`qExprStreamUndSelectClause(ExprStreamUnderlyingNode undNode)`
`void`	`qExprSubselect(ExprSubselectNode exprSubselectNode)`
`void`	`qExprTableSubpropAccessor(ExprNode exprNode, String tableName, String subpropName, ExprAggregateNode aggregationExpression)`
`void`	`qExprTableSubproperty(ExprNode exprNode, String tableName, String subpropName)`
`void`	`qExprTableTop(ExprNode exprNode, String tableName)`
`void`	`qExprTimePeriod(ExprTimePeriodImpl exprTimePeriod)`
`void`	`qExprTypeof()`
`void`	`qExprValue(ExprNode exprNode, EventBean[] eventsPerStream)`
`void`	`qExprVariable(ExprVariableNode exprVariableNode)`
`void`	`qFilter(EventBean theEvent)`
`void`	`qFilterActivationNamedWindowInsert(String namedWindowName)`
`void`	`qFilterActivationOnTrigger(String eventTypeName)`
`void`	`qFilterActivationStream(String eventTypeName, int streamNumber)`
`void`	`qFilterActivationSubselect(String eventTypeName, ExprSubselectNode subselectNode)`
`void`	`qFilterAdd(FilterValueSet filterValueSet, FilterHandle filterCallback)`
`void`	`qFilterBoolean(FilterParamIndexBooleanExpr filterParamIndexBooleanExpr)`
`void`	`qFilterBooleanExpr(int num, Map.Entry<ExprNodeAdapterBase,EventEvaluator> evals)`
`void`	`qFilterHandleSetIndexes(List<FilterParamIndexBase> indizes)`
`void`	`qFilterRemove(FilterHandle filterCallback, EventTypeIndexBuilderValueIndexesPair pair)`
`void`	`qFilterReverseIndex(FilterParamIndexLookupableBase filterParamIndex, Object propertyValue)`
`void`	`qHavingClauseJoin(EventBean[] eventsPerStream)`
`void`	`qHavingClauseNonJoin(EventBean theEvent)`
`void`	`qHistoricalScheduledEval()`
`void`	`qIndexAdd(EventTable eventTable, EventBean[] addEvents)`
`void`	`qIndexAddRemove(EventTable eventTable, EventBean[] newData, EventBean[] oldData)`
`void`	`qIndexJoinLookup(JoinExecTableLookupStrategy strategy, EventTable index)`
`void`	`qIndexRemove(EventTable eventTable, EventBean[] removeEvents)`
`void`	`qIndexSubordLookup(SubordTableLookupStrategy subordTableLookupStrategy, EventTable optionalEventIndex, int[] keyStreamNums)`
`void`	`qInfraMergeWhenThenActionItem(int count, String actionName)`
`void`	`qInfraMergeWhenThenActions(int numActions)`
`void`	`qInfraMergeWhenThenItem(boolean matched, int count)`
`void`	`qInfraMergeWhenThens(boolean matched, EventBean triggerEvent, int numWhenThens)`
`void`	`qInfraOnAction(OnTriggerType triggerType, EventBean[] triggerEvents, EventBean[] matchingEvents)`
`void`	`qInfraTriggeredLookup(SubordWMatchExprLookupStrategyType lookupStrategy)`
`void`	`qInfraUpdate(EventBean beforeUpdate, EventBean[] eventsPerStream, int length, boolean copy)`
`void`	`qInfraUpdateRHSExpr(int index, EventBeanUpdateItem updateItem)`
`void`	`qJoinCompositionHistorical()`
`void`	`qJoinCompositionQueryStrategy(boolean insert, int streamNum, EventBean[] events)`
`void`	`qJoinCompositionStepUpdIndex(int stream, EventBean[] added, EventBean[] removed)`
`void`	`qJoinCompositionStreamToWin()`
`void`	`qJoinCompositionWinToWin()`
`void`	`qJoinDispatch(EventBean[][] newDataPerStream, EventBean[][] oldDataPerStream)`
`void`	`qJoinExecFilter()`
`void`	`qJoinExecProcess(UniformPair<Set<MultiKey<EventBean>>> joinSet)`
`void`	`qJoinExexStrategy()`
`void`	`qNamedWindowCPMulti(String engineURI, Map<NamedWindowConsumerView,NamedWindowDeltaData> deltaPerConsumer, EPStatementAgentInstanceHandle handle, long time)`
`void`	`qNamedWindowCPSingle(String engineURI, List<NamedWindowConsumerView> value, EventBean[] newData, EventBean[] oldData, EPStatementAgentInstanceHandle handle, long time)`
`void`	`qNamedWindowDispatch(String engineURI)`
`void`	`qOrderBy(EventBean[] evalEventsPerStream, OrderByElement[] orderBy)`
`void`	`qOutputProcessNonBuffered(EventBean[] newData, EventBean[] oldData)`
`void`	`qOutputProcessNonBufferedJoin(Set<MultiKey<EventBean>> newEvents, Set<MultiKey<EventBean>> oldEvents)`
`void`	`qOutputProcessWCondition(EventBean[] newData, EventBean[] oldData)`
`void`	`qOutputProcessWConditionJoin(Set<MultiKey<EventBean>> newEvents, Set<MultiKey<EventBean>> oldEvents)`
`void`	`qOutputRateConditionOutputNow()`
`void`	`qOutputRateConditionScheduledEval()`
`void`	`qOutputRateConditionUpdate(int newDataLength, int oldDataLength)`
`void`	`qPatternAndEvaluateFalse(EvalAndNode evalAndNode)`
`void`	`qPatternAndEvaluateTrue(EvalAndNode evalAndNode, MatchedEventMap passUp)`
`void`	`qPatternAndQuit(EvalAndNode evalAndNode)`
`void`	`qPatternAndStart(EvalAndNode evalAndNode, MatchedEventMap beginState)`
`void`	`qPatternEveryDistinctEvalFalse(EvalEveryDistinctNode everyNode)`
`void`	`qPatternEveryDistinctEvaluateTrue(EvalEveryDistinctNode everyDistinctNode, MatchedEventMap matchEvent)`
`void`	`qPatternEveryDistinctQuit(EvalEveryDistinctNode everyNode)`
`void`	`qPatternEveryDistinctStart(EvalEveryDistinctNode everyNode, MatchedEventMap beginState)`
`void`	`qPatternEveryEvalFalse(EvalEveryNode evalEveryNode)`
`void`	`qPatternEveryEvaluateTrue(EvalEveryNode evalEveryNode, MatchedEventMap matchEvent)`
`void`	`qPatternEveryQuit(EvalEveryNode evalEveryNode)`
`void`	`qPatternEveryStart(EvalEveryNode evalEveryNode, MatchedEventMap beginState)`
`void`	`qPatternFilterMatch(EvalFilterNode filterNode, EventBean theEvent)`
`void`	`qPatternFilterQuit(EvalFilterNode evalFilterNode, MatchedEventMap beginState)`
`void`	`qPatternFilterStart(EvalFilterNode evalFilterNode, MatchedEventMap beginState)`
`void`	`qPatternFollowedByEvalFalse(EvalFollowedByNode evalFollowedByNode)`
`void`	`qPatternFollowedByEvaluateTrue(EvalFollowedByNode evalFollowedByNode, MatchedEventMap matchEvent, Integer index)`
`void`	`qPatternFollowedByQuit(EvalFollowedByNode evalFollowedByNode)`
`void`	`qPatternFollowedByStart(EvalFollowedByNode evalFollowedByNode, MatchedEventMap beginState)`
`void`	`qPatternGuardEvaluateTrue(EvalGuardNode evalGuardNode, MatchedEventMap matchEvent)`
`void`	`qPatternGuardGuardQuit(EvalGuardNode evalGuardNode)`
`void`	`qPatternGuardQuit(EvalGuardNode evalGuardNode)`
`void`	`qPatternGuardScheduledEval()`
`void`	`qPatternGuardStart(EvalGuardNode evalGuardNode, MatchedEventMap beginState)`
`void`	`qPatternMatchUntilEvalFalse(EvalMatchUntilNode evalMatchUntilNode, boolean matchFromUntil)`
`void`	`qPatternMatchUntilEvaluateTrue(EvalMatchUntilNode evalMatchUntilNode, MatchedEventMap matchEvent, boolean matchFromUntil)`
`void`	`qPatternMatchUntilQuit(EvalMatchUntilNode evalMatchUntilNode)`
`void`	`qPatternMatchUntilStart(EvalMatchUntilNode evalMatchUntilNode, MatchedEventMap beginState)`
`void`	`qPatternNotEvalFalse(EvalNotNode evalNotNode)`
`void`	`qPatternNotEvaluateTrue(EvalNotNode evalNotNode, MatchedEventMap matchEvent)`
`void`	`qPatternNotQuit(EvalNotNode evalNotNode)`
`void`	`qPatternNotStart(EvalNotNode evalNotNode, MatchedEventMap beginState)`
`void`	`qPatternObserverEvaluateTrue(EvalObserverNode evalObserverNode, MatchedEventMap matchEvent)`
`void`	`qPatternObserverQuit(EvalObserverNode evalObserverNode)`
`void`	`qPatternObserverScheduledEval()`
`void`	`qPatternObserverStart(EvalObserverNode evalObserverNode, MatchedEventMap beginState)`
`void`	`qPatternOrEvalFalse(EvalOrNode evalOrNode)`
`void`	`qPatternOrEvaluateTrue(EvalOrNode evalOrNode, MatchedEventMap matchEvent)`
`void`	`qPatternOrQuit(EvalOrNode evalOrNode)`
`void`	`qPatternOrStart(EvalOrNode evalOrNode, MatchedEventMap beginState)`
`void`	`qPatternRootEvalFalse()`
`void`	`qPatternRootEvaluateTrue(MatchedEventMap matchEvent)`
`void`	`qPatternRootQuit()`
`void`	`qPatternRootStart(MatchedEventMap root)`
`void`	`qRegEx(EventBean newEvent, RegexPartitionState partitionState)`
`void`	`qRegExPartition(ExprNode[] partitionExpressionNodes)`
`void`	`qRegExScheduledEval()`
`void`	`qRegExState(RegexNFAStateEntry currentState, LinkedHashMap<String,Pair<Integer,Boolean>> variableStreams, int[] multimatchStreamNumToVariable)`
`void`	`qRegExStateStart(RegexNFAState startState, LinkedHashMap<String,Pair<Integer,Boolean>> variableStreams, int[] multimatchStreamNumToVariable)`
`void`	`qRegIntervalState(RegexNFAStateEntry endState, LinkedHashMap<String,Pair<Integer,Boolean>> variableStreams, int[] multimatchStreamNumToVariable, long engineTime)`
`void`	`qRegIntervalValue(ExprNode exprNode)`
`void`	`qRegMeasure(RegexNFAStateEntry endState, LinkedHashMap<String,Pair<Integer,Boolean>> variableStreams, int[] multimatchStreamNumToVariable)`
`void`	`qRegOut(EventBean[] outBeans)`
`void`	`qResultSetProcessComputeGroupKeys(boolean enter, ExprNode[] groupKeyNodeExpressions, EventBean[] eventsPerStream)`
`void`	`qResultSetProcessGroupedRowPerEvent()`
`void`	`qResultSetProcessGroupedRowPerGroup()`
`void`	`qResultSetProcessSimple()`
`void`	`qResultSetProcessUngroupedFullyAgg()`
`void`	`qResultSetProcessUngroupedNonfullyAgg()`
`void`	`qRouteBetweenStmt(EventBean theEvent, EPStatementHandle epStatementHandle, boolean addToFront)`
`void`	`qScheduleAdd(long currentTime, long afterMSec, ScheduleHandle handle, long slot)`
`void`	`qScheduleEval(long currentTime)`
`void`	`qScheduleRemove(ScheduleHandle handle, long slot)`
`void`	`qSelectClause(EventBean[] eventsPerStream, boolean newData, boolean synthesize, ExprEvaluatorContext exprEvaluatorContext)`
`void`	`qSplitStream(boolean all, EventBean theEvent, ExprEvaluator[] whereClauses)`
`void`	`qSplitStreamRoute(int index)`
`void`	`qSplitStreamWhere(int index)`
`void`	`qStimulantEvent(EventBean eventBean, String engineURI)`
`void`	`qStimulantTime(long currentTime, String engineURI)`
`void`	`qSubselectAggregation(ExprNode optionalFilterExprNode)`
`void`	`qTableAddEvent(EventBean theEvent)`
`void`	`qTableDeleteEvent(EventBean theEvent)`
`void`	`qTime(long engineTime, String engineURI)`
`void`	`qTimeCP(EPStatementAgentInstanceHandle handle, long engineTime)`
`void`	`qUpdateIStream(InternalEventRouterEntry[] entries)`
`void`	`qUpdateIStreamApply(int index, InternalEventRouterEntry entry)`
`void`	`qUpdateIStreamApplyAssignmentItem(int index)`
`void`	`qUpdateIStreamApplyAssignments(InternalEventRouterEntry entry)`
`void`	`qUpdateIStreamApplyWhere()`
`void`	`qViewIndicate(View view, String viewName, EventBean[] newData, EventBean[] oldData)`
`void`	`qViewProcessIRStream(View view, String viewName, EventBean[] newData, EventBean[] oldData)`
`void`	`qViewScheduledEval(View view, String viewName)`
`void`	`qWhereClauseFilter(ExprNode exprNode, EventBean[] newData, EventBean[] oldData)`
`void`	`qWhereClauseFilterEval(int num, EventBean event, boolean newData)`
`void`	`qWhereClauseIR(EventBean[] filteredNewData, EventBean[] filteredOldData)`

Method Detail

qStimulantEvent

void qStimulantEvent(EventBean eventBean,
                     String engineURI)

aStimulantEvent
```
void aStimulantEvent()
```

qStimulantTime

void qStimulantTime(long currentTime,
                    String engineURI)

aStimulantTime
```
void aStimulantTime()
```

qEvent

void qEvent(EventBean eventBean,
            String engineURI,
            boolean providedBySendEvent)

aEvent
```
void aEvent()
```

qEventCP

void qEventCP(EventBean theEvent,
              EPStatementAgentInstanceHandle handle,
              long engineTime)

aEventCP
```
void aEventCP()
```

qTime

void qTime(long engineTime,
           String engineURI)

aTime
```
void aTime()
```

qTimeCP

void qTimeCP(EPStatementAgentInstanceHandle handle,
             long engineTime)

aTimeCP
```
void aTimeCP()
```

qNamedWindowDispatch

void qNamedWindowDispatch(String engineURI)

aNamedWindowDispatch
```
void aNamedWindowDispatch()
```

qNamedWindowCPSingle

void qNamedWindowCPSingle(String engineURI,
                          List<NamedWindowConsumerView> value,
                          EventBean[] newData,
                          EventBean[] oldData,
                          EPStatementAgentInstanceHandle handle,
                          long time)

aNamedWindowCPSingle
```
void aNamedWindowCPSingle()
```

qNamedWindowCPMulti

void qNamedWindowCPMulti(String engineURI,
                         Map<NamedWindowConsumerView,NamedWindowDeltaData> deltaPerConsumer,
                         EPStatementAgentInstanceHandle handle,
                         long time)

aNamedWindowCPMulti
```
void aNamedWindowCPMulti()
```

qRegEx

void qRegEx(EventBean newEvent,
            RegexPartitionState partitionState)

aRegEx

void aRegEx(RegexPartitionState partitionState,
            List<RegexNFAStateEntry> endStates,
            List<RegexNFAStateEntry> terminationStates)

qRegExState

void qRegExState(RegexNFAStateEntry currentState,
                 LinkedHashMap<String,Pair<Integer,Boolean>> variableStreams,
                 int[] multimatchStreamNumToVariable)

aRegExState

void aRegExState(List<RegexNFAStateEntry> next,
                 LinkedHashMap<String,Pair<Integer,Boolean>> variableStreams,
                 int[] multimatchStreamNumToVariable)

qRegExStateStart

void qRegExStateStart(RegexNFAState startState,
                      LinkedHashMap<String,Pair<Integer,Boolean>> variableStreams,
                      int[] multimatchStreamNumToVariable)

aRegExStateStart

void aRegExStateStart(List<RegexNFAStateEntry> nextStates,
                      LinkedHashMap<String,Pair<Integer,Boolean>> variableStreams,
                      int[] multimatchStreamNumToVariable)

qRegExPartition

void qRegExPartition(ExprNode[] partitionExpressionNodes)

aRegExPartition

void aRegExPartition(boolean exists,
                     RegexPartitionState state)

qRegIntervalValue

void qRegIntervalValue(ExprNode exprNode)

aRegIntervalValue
```
void aRegIntervalValue(long result)
```

qRegIntervalState

void qRegIntervalState(RegexNFAStateEntry endState,
                       LinkedHashMap<String,Pair<Integer,Boolean>> variableStreams,
                       int[] multimatchStreamNumToVariable,
                       long engineTime)

aRegIntervalState

void aRegIntervalState(boolean scheduled)

qRegOut
```
void qRegOut(EventBean[] outBeans)
```

aRegOut
```
void aRegOut()
```

qRegMeasure

void qRegMeasure(RegexNFAStateEntry endState,
                 LinkedHashMap<String,Pair<Integer,Boolean>> variableStreams,
                 int[] multimatchStreamNumToVariable)

aRegMeasure
```
void aRegMeasure(EventBean outBean)
```

qRegExScheduledEval
```
void qRegExScheduledEval()
```

aRegExScheduledEval
```
void aRegExScheduledEval()
```

qExprBool

void qExprBool(ExprNode exprNode,
               EventBean[] eventsPerStream)

aExprBool
```
void aExprBool(Boolean result)
```

qExprValue

void qExprValue(ExprNode exprNode,
                EventBean[] eventsPerStream)

aExprValue
```
void aExprValue(Object result)
```

qExprEquals
```
void qExprEquals(ExprNode exprNode)
```

aExprEquals
```
void aExprEquals(Boolean result)
```

qExprAnd
```
void qExprAnd(ExprNode exprNode)
```

aExprAnd
```
void aExprAnd(Boolean result)
```

qExprLike
```
void qExprLike(ExprNode exprNode)
```

aExprLike
```
void aExprLike(Boolean result)
```

qExprBitwise

void qExprBitwise(ExprNode exprNode,
                  BitWiseOpEnum bitWiseOpEnum)

aExprBitwise
```
void aExprBitwise(Object result)
```

qExprMath

void qExprMath(ExprMathNode exprMathNode,
               String op)

aExprMath
```
void aExprMath(Object result)
```

qExprRegexp

void qExprRegexp(ExprRegexpNode exprRegexpNode)

aExprRegexp
```
void aExprRegexp(Boolean result)
```

qExprIdent

void qExprIdent(String fullUnresolvedName)

aExprIdent
```
void aExprIdent(Object result)
```

qExprTypeof
```
void qExprTypeof()
```

aExprTypeof
```
void aExprTypeof(String typeName)
```

qExprOr
```
void qExprOr(ExprOrNode exprOrNode)
```

aExprOr
```
void aExprOr(Boolean result)
```

qExprIn

void qExprIn(ExprInNodeImpl exprInNode)

aExprIn
```
void aExprIn(Boolean result)
```

qExprCoalesce

void qExprCoalesce(ExprCoalesceNode exprCoalesceNode)

aExprCoalesce
```
void aExprCoalesce(Object value)
```

qExprConcat

void qExprConcat(ExprConcatNode exprConcatNode)

aExprConcat
```
void aExprConcat(String result)
```

qaExprConst
```
void qaExprConst(Object result)
```

qaExprTimestamp

void qaExprTimestamp(ExprTimestampNode exprTimestampNode,
                     long value)

qExprBetween

void qExprBetween(ExprBetweenNodeImpl exprBetweenNode)

aExprBetween
```
void aExprBetween(Boolean result)
```

qExprCast

void qExprCast(ExprCastNode exprCastNode)

aExprCast
```
void aExprCast(Object result)
```

qExprCase

void qExprCase(ExprCaseNode exprCaseNode)

aExprCase
```
void aExprCase(Object result)
```

qExprArray

void qExprArray(ExprArrayNode exprArrayNode)

aExprArray
```
void aExprArray(Object result)
```

qExprEqualsAnyOrAll

void qExprEqualsAnyOrAll(ExprEqualsAllAnyNode exprEqualsAllAnyNode)

aExprEqualsAnyOrAll

void aExprEqualsAnyOrAll(Boolean result)

qExprMinMaxRow

void qExprMinMaxRow(ExprMinMaxRowNode exprMinMaxRowNode)

aExprMinMaxRow
```
void aExprMinMaxRow(Object result)
```

qExprNew

void qExprNew(ExprNewStructNode exprNewNode)

aExprNew

void aExprNew(Map<String,Object> props)

qExprNot

void qExprNot(ExprNotNode exprNotNode)

aExprNot
```
void aExprNot(Boolean result)
```

qExprPropExists

void qExprPropExists(ExprPropertyExistsNode exprPropertyExistsNode)

aExprPropExists
```
void aExprPropExists(boolean exists)
```

qExprRelOpAnyOrAll

void qExprRelOpAnyOrAll(ExprRelationalOpAllAnyNode exprRelationalOpAllAnyNode,
                        String op)

aExprRelOpAnyOrAll

void aExprRelOpAnyOrAll(Boolean result)

qExprRelOp

void qExprRelOp(ExprRelationalOpNodeImpl exprRelationalOpNode,
                String op)

aExprRelOp
```
void aExprRelOp(Boolean result)
```

qExprStreamUnd

void qExprStreamUnd(ExprStreamUnderlyingNodeImpl exprStreamUnderlyingNode)

aExprStreamUnd
```
void aExprStreamUnd(Object result)
```

qExprStreamUndSelectClause

void qExprStreamUndSelectClause(ExprStreamUnderlyingNode undNode)

aExprStreamUndSelectClause

void aExprStreamUndSelectClause(EventBean event)

qExprIs

void qExprIs(ExprEqualsNodeImpl exprNode)

aExprIs
```
void aExprIs(boolean result)
```

qExprVariable

void qExprVariable(ExprVariableNode exprVariableNode)

aExprVariable
```
void aExprVariable(Object value)
```

qExprTimePeriod

void qExprTimePeriod(ExprTimePeriodImpl exprTimePeriod)

aExprTimePeriod
```
void aExprTimePeriod(Object result)
```

qExprInstanceof

void qExprInstanceof(ExprInstanceofNode exprInstanceofNode)

aExprInstanceof
```
void aExprInstanceof(Boolean result)
```

qExprContextProp

void qExprContextProp(ExprContextPropertyNodeImpl exprContextPropertyNode)

aExprContextProp
```
void aExprContextProp(Object result)
```

qExprPlugInSingleRow

void qExprPlugInSingleRow(Method method)

aExprPlugInSingleRow

void aExprPlugInSingleRow(Object result)

qaExprAggValue

void qaExprAggValue(ExprAggregateNodeBase exprAggregateNodeBase,
                    Object value)

qExprSubselect

void qExprSubselect(ExprSubselectNode exprSubselectNode)

aExprSubselect
```
void aExprSubselect(Object result)
```

qExprDot

void qExprDot(ExprDotNode exprDotNode)

aExprDot
```
void aExprDot(Object result)
```

qExprDotChain

void qExprDotChain(EPType targetTypeInfo,
                   Object target,
                   ExprDotEval[] evalUnpacking)

aExprDotChain
```
void aExprDotChain()
```

qExprDotChainElement

void qExprDotChainElement(int num,
                          ExprDotEval methodEval)

aExprDotChainElement

void aExprDotChainElement(EPType typeInfo,
                          Object result)

qaExprIStream

void qaExprIStream(ExprIStreamNode exprIStreamNode,
                   boolean newData)

qExprDeclared

void qExprDeclared(ExpressionDeclItem parent)

aExprDeclared
```
void aExprDeclared(Object value)
```

qExprPrev

void qExprPrev(ExprPreviousNode exprPreviousNode,
               boolean newData)

aExprPrev
```
void aExprPrev(Object result)
```

qExprPrior

void qExprPrior(ExprPriorNode exprPriorNode)

aExprPrior
```
void aExprPrior(Object result)
```

qExprStreamUndMethod

void qExprStreamUndMethod(ExprDotNode exprDotEvalStreamMethod)

aExprStreamUndMethod

void aExprStreamUndMethod(Object result)

qExprStreamEventMethod

void qExprStreamEventMethod(ExprDotNode exprDotNode)

aExprStreamEventMethod

void aExprStreamEventMethod(Object result)

qExprTableSubproperty

void qExprTableSubproperty(ExprNode exprNode,
                           String tableName,
                           String subpropName)

aExprTableSubproperty

void aExprTableSubproperty(Object result)

qExprTableTop

void qExprTableTop(ExprNode exprNode,
                   String tableName)

aExprTableTop
```
void aExprTableTop(Object result)
```

qExprTableSubpropAccessor

void qExprTableSubpropAccessor(ExprNode exprNode,
                               String tableName,
                               String subpropName,
                               ExprAggregateNode aggregationExpression)

aExprTableSubpropAccessor

void aExprTableSubpropAccessor(Object result)

qScheduleAdd

void qScheduleAdd(long currentTime,
                  long afterMSec,
                  ScheduleHandle handle,
                  long slot)

aScheduleAdd
```
void aScheduleAdd()
```

qScheduleRemove

void qScheduleRemove(ScheduleHandle handle,
                     long slot)

aScheduleRemove
```
void aScheduleRemove()
```

qScheduleEval
```
void qScheduleEval(long currentTime)
```

aScheduleEval

void aScheduleEval(Collection<ScheduleHandle> handles)

qPatternAndEvaluateTrue

void qPatternAndEvaluateTrue(EvalAndNode evalAndNode,
                             MatchedEventMap passUp)

aPatternAndEvaluateTrue

void aPatternAndEvaluateTrue(boolean quitted)

qPatternAndQuit

void qPatternAndQuit(EvalAndNode evalAndNode)

aPatternAndQuit
```
void aPatternAndQuit()
```

qPatternAndEvaluateFalse

void qPatternAndEvaluateFalse(EvalAndNode evalAndNode)

aPatternAndEvaluateFalse
```
void aPatternAndEvaluateFalse()
```

qPatternAndStart

void qPatternAndStart(EvalAndNode evalAndNode,
                      MatchedEventMap beginState)

aPatternAndStart
```
void aPatternAndStart()
```

qPatternFollowedByEvaluateTrue

void qPatternFollowedByEvaluateTrue(EvalFollowedByNode evalFollowedByNode,
                                    MatchedEventMap matchEvent,
                                    Integer index)

aPatternFollowedByEvaluateTrue

void aPatternFollowedByEvaluateTrue(boolean quitted)

qPatternFollowedByQuit

void qPatternFollowedByQuit(EvalFollowedByNode evalFollowedByNode)

aPatternFollowedByQuit
```
void aPatternFollowedByQuit()
```

qPatternFollowedByEvalFalse

void qPatternFollowedByEvalFalse(EvalFollowedByNode evalFollowedByNode)

aPatternFollowedByEvalFalse
```
void aPatternFollowedByEvalFalse()
```

qPatternFollowedByStart

void qPatternFollowedByStart(EvalFollowedByNode evalFollowedByNode,
                             MatchedEventMap beginState)

aPatternFollowedByStart
```
void aPatternFollowedByStart()
```

qPatternOrEvaluateTrue

void qPatternOrEvaluateTrue(EvalOrNode evalOrNode,
                            MatchedEventMap matchEvent)

aPatternOrEvaluateTrue

void aPatternOrEvaluateTrue(boolean quitted)

qPatternOrEvalFalse

void qPatternOrEvalFalse(EvalOrNode evalOrNode)

aPatternOrEvalFalse
```
void aPatternOrEvalFalse()
```

qPatternOrQuit

void qPatternOrQuit(EvalOrNode evalOrNode)

aPatternOrQuit
```
void aPatternOrQuit()
```

aPatternOrStart
```
void aPatternOrStart()
```

qPatternOrStart

void qPatternOrStart(EvalOrNode evalOrNode,
                     MatchedEventMap beginState)

qPatternFilterMatch

void qPatternFilterMatch(EvalFilterNode filterNode,
                         EventBean theEvent)

aPatternFilterMatch

void aPatternFilterMatch(boolean quitted)

qPatternFilterStart

void qPatternFilterStart(EvalFilterNode evalFilterNode,
                         MatchedEventMap beginState)

aPatternFilterStart
```
void aPatternFilterStart()
```

qPatternFilterQuit

void qPatternFilterQuit(EvalFilterNode evalFilterNode,
                        MatchedEventMap beginState)

aPatternFilterQuit
```
void aPatternFilterQuit()
```

qPatternRootEvaluateTrue

void qPatternRootEvaluateTrue(MatchedEventMap matchEvent)

aPatternRootEvaluateTrue

void aPatternRootEvaluateTrue(boolean quitted)

qPatternRootStart

void qPatternRootStart(MatchedEventMap root)

aPatternRootStart
```
void aPatternRootStart()
```

qPatternRootQuit
```
void qPatternRootQuit()
```

aPatternRootQuit
```
void aPatternRootQuit()
```

qPatternRootEvalFalse
```
void qPatternRootEvalFalse()
```

aPatternRootEvalFalse
```
void aPatternRootEvalFalse()
```

qPatternEveryEvaluateTrue

void qPatternEveryEvaluateTrue(EvalEveryNode evalEveryNode,
                               MatchedEventMap matchEvent)

aPatternEveryEvaluateTrue
```
void aPatternEveryEvaluateTrue()
```

qPatternEveryStart

void qPatternEveryStart(EvalEveryNode evalEveryNode,
                        MatchedEventMap beginState)

aPatternEveryStart
```
void aPatternEveryStart()
```

qPatternEveryEvalFalse

void qPatternEveryEvalFalse(EvalEveryNode evalEveryNode)

aPatternEveryEvalFalse
```
void aPatternEveryEvalFalse()
```

qPatternEveryQuit

void qPatternEveryQuit(EvalEveryNode evalEveryNode)

aPatternEveryQuit
```
void aPatternEveryQuit()
```

qPatternEveryDistinctEvaluateTrue

void qPatternEveryDistinctEvaluateTrue(EvalEveryDistinctNode everyDistinctNode,
                                       MatchedEventMap matchEvent)

aPatternEveryDistinctEvaluateTrue

void aPatternEveryDistinctEvaluateTrue(Set<Object> keysFromNodeNoExpire,
                                       LinkedHashMap<Object,Long> keysFromNodeExpire,
                                       Object matchEventKey,
                                       boolean haveSeenThis)

qPatternEveryDistinctQuit

void qPatternEveryDistinctQuit(EvalEveryDistinctNode everyNode)

aPatternEveryDistinctQuit
```
void aPatternEveryDistinctQuit()
```

qPatternEveryDistinctEvalFalse

void qPatternEveryDistinctEvalFalse(EvalEveryDistinctNode everyNode)

aPatternEveryDistinctEvalFalse
```
void aPatternEveryDistinctEvalFalse()
```

qPatternEveryDistinctStart

void qPatternEveryDistinctStart(EvalEveryDistinctNode everyNode,
                                MatchedEventMap beginState)

aPatternEveryDistinctStart
```
void aPatternEveryDistinctStart()
```

qPatternGuardEvaluateTrue

void qPatternGuardEvaluateTrue(EvalGuardNode evalGuardNode,
                               MatchedEventMap matchEvent)

aPatternGuardEvaluateTrue

void aPatternGuardEvaluateTrue(boolean quitted)

qPatternGuardStart

void qPatternGuardStart(EvalGuardNode evalGuardNode,
                        MatchedEventMap beginState)

aPatternGuardStart
```
void aPatternGuardStart()
```

qPatternGuardQuit

void qPatternGuardQuit(EvalGuardNode evalGuardNode)

aPatternGuardQuit
```
void aPatternGuardQuit()
```

qPatternGuardGuardQuit

void qPatternGuardGuardQuit(EvalGuardNode evalGuardNode)

aPatternGuardGuardQuit
```
void aPatternGuardGuardQuit()
```

qPatternGuardScheduledEval
```
void qPatternGuardScheduledEval()
```

aPatternGuardScheduledEval
```
void aPatternGuardScheduledEval()
```

qPatternMatchUntilEvaluateTrue

void qPatternMatchUntilEvaluateTrue(EvalMatchUntilNode evalMatchUntilNode,
                                    MatchedEventMap matchEvent,
                                    boolean matchFromUntil)

aPatternMatchUntilEvaluateTrue

void aPatternMatchUntilEvaluateTrue(boolean quitted)

qPatternMatchUntilStart

void qPatternMatchUntilStart(EvalMatchUntilNode evalMatchUntilNode,
                             MatchedEventMap beginState)

aPatternMatchUntilStart
```
void aPatternMatchUntilStart()
```

qPatternMatchUntilEvalFalse

void qPatternMatchUntilEvalFalse(EvalMatchUntilNode evalMatchUntilNode,
                                 boolean matchFromUntil)

aPatternMatchUntilEvalFalse
```
void aPatternMatchUntilEvalFalse()
```

qPatternMatchUntilQuit

void qPatternMatchUntilQuit(EvalMatchUntilNode evalMatchUntilNode)

aPatternMatchUntilQuit
```
void aPatternMatchUntilQuit()
```

qPatternNotEvaluateTrue

void qPatternNotEvaluateTrue(EvalNotNode evalNotNode,
                             MatchedEventMap matchEvent)

aPatternNotEvaluateTrue

void aPatternNotEvaluateTrue(boolean quitted)

aPatternNotQuit
```
void aPatternNotQuit()
```

qPatternNotQuit

void qPatternNotQuit(EvalNotNode evalNotNode)

qPatternNotStart

void qPatternNotStart(EvalNotNode evalNotNode,
                      MatchedEventMap beginState)

aPatternNotStart
```
void aPatternNotStart()
```

qPatternNotEvalFalse

void qPatternNotEvalFalse(EvalNotNode evalNotNode)

aPatternNotEvalFalse
```
void aPatternNotEvalFalse()
```

qPatternObserverEvaluateTrue

void qPatternObserverEvaluateTrue(EvalObserverNode evalObserverNode,
                                  MatchedEventMap matchEvent)

aPatternObserverEvaluateTrue
```
void aPatternObserverEvaluateTrue()
```

qPatternObserverStart

void qPatternObserverStart(EvalObserverNode evalObserverNode,
                           MatchedEventMap beginState)

aPatternObserverStart
```
void aPatternObserverStart()
```

qPatternObserverQuit

void qPatternObserverQuit(EvalObserverNode evalObserverNode)

aPatternObserverQuit
```
void aPatternObserverQuit()
```

qPatternObserverScheduledEval
```
void qPatternObserverScheduledEval()
```

aPatternObserverScheduledEval
```
void aPatternObserverScheduledEval()
```

qContextPartitionAllocate

void qContextPartitionAllocate(AgentInstanceContext agentInstanceContext)

aContextPartitionAllocate
```
void aContextPartitionAllocate()
```

qContextPartitionDestroy

void qContextPartitionDestroy(AgentInstanceContext agentInstanceContext)

aContextPartitionDestroy
```
void aContextPartitionDestroy()
```

qContextScheduledEval

void qContextScheduledEval(ContextDescriptor contextDescriptor)

aContextScheduledEval
```
void aContextScheduledEval()
```

qOutputProcessNonBuffered

void qOutputProcessNonBuffered(EventBean[] newData,
                               EventBean[] oldData)

aOutputProcessNonBuffered
```
void aOutputProcessNonBuffered()
```

qOutputProcessNonBufferedJoin

void qOutputProcessNonBufferedJoin(Set<MultiKey<EventBean>> newEvents,
                                   Set<MultiKey<EventBean>> oldEvents)

aOutputProcessNonBufferedJoin
```
void aOutputProcessNonBufferedJoin()
```

qOutputProcessWCondition

void qOutputProcessWCondition(EventBean[] newData,
                              EventBean[] oldData)

aOutputProcessWCondition

void aOutputProcessWCondition(boolean buffered)

qOutputProcessWConditionJoin

void qOutputProcessWConditionJoin(Set<MultiKey<EventBean>> newEvents,
                                  Set<MultiKey<EventBean>> oldEvents)

aOutputProcessWConditionJoin

void aOutputProcessWConditionJoin(boolean buffered)

qOutputRateConditionUpdate

void qOutputRateConditionUpdate(int newDataLength,
                                int oldDataLength)

aOutputRateConditionUpdate
```
void aOutputRateConditionUpdate()
```

qOutputRateConditionOutputNow
```
void qOutputRateConditionOutputNow()
```

aOutputRateConditionOutputNow

void aOutputRateConditionOutputNow(boolean generate)

qOutputRateConditionScheduledEval

void qOutputRateConditionScheduledEval()

aOutputRateConditionScheduledEval

void aOutputRateConditionScheduledEval()

qResultSetProcessSimple
```
void qResultSetProcessSimple()
```

aResultSetProcessSimple

void aResultSetProcessSimple(EventBean[] selectNewEvents,
                             EventBean[] selectOldEvents)

qResultSetProcessUngroupedFullyAgg

void qResultSetProcessUngroupedFullyAgg()

aResultSetProcessUngroupedFullyAgg

void aResultSetProcessUngroupedFullyAgg(EventBean[] selectNewEvents,
                                        EventBean[] selectOldEvents)

qResultSetProcessUngroupedNonfullyAgg

void qResultSetProcessUngroupedNonfullyAgg()

aResultSetProcessUngroupedNonfullyAgg

void aResultSetProcessUngroupedNonfullyAgg(EventBean[] selectNewEvents,
                                           EventBean[] selectOldEvents)

qResultSetProcessGroupedRowPerGroup

void qResultSetProcessGroupedRowPerGroup()

aResultSetProcessGroupedRowPerGroup

void aResultSetProcessGroupedRowPerGroup(EventBean[] selectNewEvents,
                                         EventBean[] selectOldEvents)

qResultSetProcessGroupedRowPerEvent

void qResultSetProcessGroupedRowPerEvent()

aResultSetProcessGroupedRowPerEvent

void aResultSetProcessGroupedRowPerEvent(EventBean[] selectNewEvents,
                                         EventBean[] selectOldEvents)

qResultSetProcessComputeGroupKeys

void qResultSetProcessComputeGroupKeys(boolean enter,
                                       ExprNode[] groupKeyNodeExpressions,
                                       EventBean[] eventsPerStream)

aResultSetProcessComputeGroupKeys

void aResultSetProcessComputeGroupKeys(boolean enter,
                                       Object groupKeysPerEvent)

qAggregationUngroupedApplyEnterLeave

void qAggregationUngroupedApplyEnterLeave(boolean enter,
                                          int numAggregators,
                                          int numAccessStates)

aAggregationUngroupedApplyEnterLeave

void aAggregationUngroupedApplyEnterLeave(boolean enter)

qAggregationGroupedApplyEnterLeave

void qAggregationGroupedApplyEnterLeave(boolean enter,
                                        int numAggregators,
                                        int numAccessStates,
                                        Object groupKey)

aAggregationGroupedApplyEnterLeave

void aAggregationGroupedApplyEnterLeave(boolean enter)

qAggregationGroupedRollupEvalParam

void qAggregationGroupedRollupEvalParam(boolean enter,
                                        int length)

aAggregationGroupedRollupEvalParam

void aAggregationGroupedRollupEvalParam(Object result)

qAggNoAccessEnterLeave

void qAggNoAccessEnterLeave(boolean enter,
                            int index,
                            AggregationMethod aggregationMethod,
                            ExprNode aggExpr)

aAggNoAccessEnterLeave

void aAggNoAccessEnterLeave(boolean enter,
                            int index,
                            AggregationMethod aggregationMethod)

qAggAccessEnterLeave

void qAggAccessEnterLeave(boolean enter,
                          int index,
                          AggregationState state,
                          ExprNode aggExpr)

aAggAccessEnterLeave

void aAggAccessEnterLeave(boolean enter,
                          int index,
                          AggregationState state)

qSelectClause

void qSelectClause(EventBean[] eventsPerStream,
                   boolean newData,
                   boolean synthesize,
                   ExprEvaluatorContext exprEvaluatorContext)

aSelectClause

void aSelectClause(boolean newData,
                   EventBean event,
                   Object[] subscriberParameters)

qViewProcessIRStream

void qViewProcessIRStream(View view,
                          String viewName,
                          EventBean[] newData,
                          EventBean[] oldData)

aViewProcessIRStream
```
void aViewProcessIRStream()
```

qViewScheduledEval

void qViewScheduledEval(View view,
                        String viewName)

aViewScheduledEval
```
void aViewScheduledEval()
```

qViewIndicate

void qViewIndicate(View view,
                   String viewName,
                   EventBean[] newData,
                   EventBean[] oldData)

aViewIndicate
```
void aViewIndicate()
```

qSubselectAggregation

void qSubselectAggregation(ExprNode optionalFilterExprNode)

aSubselectAggregation
```
void aSubselectAggregation()
```

qFilterActivationSubselect

void qFilterActivationSubselect(String eventTypeName,
                                ExprSubselectNode subselectNode)

aFilterActivationSubselect
```
void aFilterActivationSubselect()
```

qFilterActivationStream

void qFilterActivationStream(String eventTypeName,
                             int streamNumber)

aFilterActivationStream
```
void aFilterActivationStream()
```

qFilterActivationNamedWindowInsert

void qFilterActivationNamedWindowInsert(String namedWindowName)

aFilterActivationNamedWindowInsert

void aFilterActivationNamedWindowInsert()

qFilterActivationOnTrigger

void qFilterActivationOnTrigger(String eventTypeName)

aFilterActivationOnTrigger
```
void aFilterActivationOnTrigger()
```

qRouteBetweenStmt

void qRouteBetweenStmt(EventBean theEvent,
                       EPStatementHandle epStatementHandle,
                       boolean addToFront)

aRouteBetweenStmt
```
void aRouteBetweenStmt()
```

qIndexAddRemove

void qIndexAddRemove(EventTable eventTable,
                     EventBean[] newData,
                     EventBean[] oldData)

aIndexAddRemove
```
void aIndexAddRemove()
```

qIndexAdd

void qIndexAdd(EventTable eventTable,
               EventBean[] addEvents)

aIndexAdd
```
void aIndexAdd()
```

qIndexRemove

void qIndexRemove(EventTable eventTable,
                  EventBean[] removeEvents)

aIndexRemove
```
void aIndexRemove()
```

qIndexSubordLookup

void qIndexSubordLookup(SubordTableLookupStrategy subordTableLookupStrategy,
                        EventTable optionalEventIndex,
                        int[] keyStreamNums)

aIndexSubordLookup

void aIndexSubordLookup(Collection<EventBean> events,
                        Object keys)

qIndexJoinLookup

void qIndexJoinLookup(JoinExecTableLookupStrategy strategy,
                      EventTable index)

aIndexJoinLookup

void aIndexJoinLookup(Set<EventBean> result,
                      Object keys)

qFilter
```
void qFilter(EventBean theEvent)
```

aFilter

void aFilter(Collection<FilterHandle> matches)

qFilterHandleSetIndexes

void qFilterHandleSetIndexes(List<FilterParamIndexBase> indizes)

aFilterHandleSetIndexes
```
void aFilterHandleSetIndexes()
```

qaFilterHandleSetCallbacks

void qaFilterHandleSetCallbacks(Set<FilterHandle> callbackSet)

qFilterReverseIndex

void qFilterReverseIndex(FilterParamIndexLookupableBase filterParamIndex,
                         Object propertyValue)

aFilterReverseIndex

void aFilterReverseIndex(Boolean match)

qFilterBoolean

void qFilterBoolean(FilterParamIndexBooleanExpr filterParamIndexBooleanExpr)

aFilterBoolean
```
void aFilterBoolean()
```

qFilterBooleanExpr

void qFilterBooleanExpr(int num,
                        Map.Entry<ExprNodeAdapterBase,EventEvaluator> evals)

aFilterBooleanExpr

void aFilterBooleanExpr(boolean result)

qFilterAdd

void qFilterAdd(FilterValueSet filterValueSet,
                FilterHandle filterCallback)

aFilterAdd
```
void aFilterAdd()
```

qFilterRemove

void qFilterRemove(FilterHandle filterCallback,
                   EventTypeIndexBuilderValueIndexesPair pair)

aFilterRemove
```
void aFilterRemove()
```

qWhereClauseFilter

void qWhereClauseFilter(ExprNode exprNode,
                        EventBean[] newData,
                        EventBean[] oldData)

aWhereClauseFilter

void aWhereClauseFilter(EventBean[] filteredNewData,
                        EventBean[] filteredOldData)

qWhereClauseFilterEval

void qWhereClauseFilterEval(int num,
                            EventBean event,
                            boolean newData)

aWhereClauseFilterEval

void aWhereClauseFilterEval(Boolean pass)

qWhereClauseIR

void qWhereClauseIR(EventBean[] filteredNewData,
                    EventBean[] filteredOldData)

aWhereClauseIR
```
void aWhereClauseIR()
```

qHavingClauseNonJoin

void qHavingClauseNonJoin(EventBean theEvent)

aHavingClauseNonJoin

void aHavingClauseNonJoin(Boolean pass)

qHavingClauseJoin

void qHavingClauseJoin(EventBean[] eventsPerStream)

aHavingClauseJoin
```
void aHavingClauseJoin(Boolean pass)
```

qOrderBy

void qOrderBy(EventBean[] evalEventsPerStream,
              OrderByElement[] orderBy)

aOrderBy
```
void aOrderBy(Object values)
```

qJoinDispatch

void qJoinDispatch(EventBean[][] newDataPerStream,
                   EventBean[][] oldDataPerStream)

aJoinDispatch
```
void aJoinDispatch()
```

qJoinExexStrategy
```
void qJoinExexStrategy()
```

aJoinExecStrategy

void aJoinExecStrategy(UniformPair<Set<MultiKey<EventBean>>> joinSet)

qJoinExecFilter
```
void qJoinExecFilter()
```

aJoinExecFilter

void aJoinExecFilter(Set<MultiKey<EventBean>> newEvents,
                     Set<MultiKey<EventBean>> oldEvents)

qJoinExecProcess

void qJoinExecProcess(UniformPair<Set<MultiKey<EventBean>>> joinSet)

aJoinExecProcess
```
void aJoinExecProcess()
```

qJoinCompositionStreamToWin
```
void qJoinCompositionStreamToWin()
```

aJoinCompositionStreamToWin

void aJoinCompositionStreamToWin(Set<MultiKey<EventBean>> newResults)

qJoinCompositionWinToWin
```
void qJoinCompositionWinToWin()
```

aJoinCompositionWinToWin

void aJoinCompositionWinToWin(Set<MultiKey<EventBean>> newResults,
                              Set<MultiKey<EventBean>> oldResults)

qJoinCompositionHistorical
```
void qJoinCompositionHistorical()
```

aJoinCompositionHistorical

void aJoinCompositionHistorical(Set<MultiKey<EventBean>> newResults,
                                Set<MultiKey<EventBean>> oldResults)

qJoinCompositionStepUpdIndex

void qJoinCompositionStepUpdIndex(int stream,
                                  EventBean[] added,
                                  EventBean[] removed)

aJoinCompositionStepUpdIndex
```
void aJoinCompositionStepUpdIndex()
```

qJoinCompositionQueryStrategy

void qJoinCompositionQueryStrategy(boolean insert,
                                   int streamNum,
                                   EventBean[] events)

aJoinCompositionQueryStrategy
```
void aJoinCompositionQueryStrategy()
```

qInfraTriggeredLookup

void qInfraTriggeredLookup(SubordWMatchExprLookupStrategyType lookupStrategy)

aInfraTriggeredLookup

void aInfraTriggeredLookup(EventBean[] result)

qInfraOnAction

void qInfraOnAction(OnTriggerType triggerType,
                    EventBean[] triggerEvents,
                    EventBean[] matchingEvents)

aInfraOnAction
```
void aInfraOnAction()
```

qInfraUpdate

void qInfraUpdate(EventBean beforeUpdate,
                  EventBean[] eventsPerStream,
                  int length,
                  boolean copy)

aInfraUpdate

void aInfraUpdate(EventBean afterUpdate)

qInfraUpdateRHSExpr

void qInfraUpdateRHSExpr(int index,
                         EventBeanUpdateItem updateItem)

aInfraUpdateRHSExpr

void aInfraUpdateRHSExpr(Object result)

qInfraMergeWhenThens

void qInfraMergeWhenThens(boolean matched,
                          EventBean triggerEvent,
                          int numWhenThens)

aInfraMergeWhenThens

void aInfraMergeWhenThens(boolean matched)

qInfraMergeWhenThenItem

void qInfraMergeWhenThenItem(boolean matched,
                             int count)

aInfraMergeWhenThenItem

void aInfraMergeWhenThenItem(boolean matched,
                             boolean actionsApplied)

qInfraMergeWhenThenActions

void qInfraMergeWhenThenActions(int numActions)

aInfraMergeWhenThenActions
```
void aInfraMergeWhenThenActions()
```

qInfraMergeWhenThenActionItem

void qInfraMergeWhenThenActionItem(int count,
                                   String actionName)

aInfraMergeWhenThenActionItem

void aInfraMergeWhenThenActionItem(boolean applies)

qEngineManagementStmtCompileStart

void qEngineManagementStmtCompileStart(String engineURI,
                                       int statementId,
                                       String statementName,
                                       String epl,
                                       long engineTime)

aEngineManagementStmtCompileStart

void aEngineManagementStmtCompileStart(boolean success,
                                       String message)

qaEngineManagementStmtStarted

void qaEngineManagementStmtStarted(String engineURI,
                                   int statementId,
                                   String statementName,
                                   String epl,
                                   long engineTime)

qEngineManagementStmtStop

void qEngineManagementStmtStop(EPStatementState targetState,
                               String engineURI,
                               int statementId,
                               String statementName,
                               String epl,
                               long engineTime)

aEngineManagementStmtStop
```
void aEngineManagementStmtStop()
```

qaStatementResultExecute

void qaStatementResultExecute(UniformPair<EventBean[]> events,
                              int statementId,
                              String statementName,
                              int agentInstanceId,
                              long threadId)

qSplitStream

void qSplitStream(boolean all,
                  EventBean theEvent,
                  ExprEvaluator[] whereClauses)

aSplitStream

void aSplitStream(boolean all,
                  boolean handled)

qSplitStreamWhere
```
void qSplitStreamWhere(int index)
```

aSplitStreamWhere
```
void aSplitStreamWhere(Boolean pass)
```

qSplitStreamRoute
```
void qSplitStreamRoute(int index)
```

aSplitStreamRoute
```
void aSplitStreamRoute()
```

qUpdateIStream

void qUpdateIStream(InternalEventRouterEntry[] entries)

aUpdateIStream

void aUpdateIStream(EventBean finalEvent,
                    boolean haveCloned)

qUpdateIStreamApply

void qUpdateIStreamApply(int index,
                         InternalEventRouterEntry entry)

aUpdateIStreamApply

void aUpdateIStreamApply(EventBean updated,
                         boolean applied)

qUpdateIStreamApplyWhere
```
void qUpdateIStreamApplyWhere()
```

aUpdateIStreamApplyWhere

void aUpdateIStreamApplyWhere(Boolean result)

qUpdateIStreamApplyAssignments

void qUpdateIStreamApplyAssignments(InternalEventRouterEntry entry)

aUpdateIStreamApplyAssignments

void aUpdateIStreamApplyAssignments(Object[] values)

qUpdateIStreamApplyAssignmentItem

void qUpdateIStreamApplyAssignmentItem(int index)

aUpdateIStreamApplyAssignmentItem

void aUpdateIStreamApplyAssignmentItem(Object value)

qHistoricalScheduledEval
```
void qHistoricalScheduledEval()
```

aHistoricalScheduledEval
```
void aHistoricalScheduledEval()
```

qTableAddEvent

void qTableAddEvent(EventBean theEvent)

aTableAddEvent
```
void aTableAddEvent()
```

qTableDeleteEvent

void qTableDeleteEvent(EventBean theEvent)

aTableDeleteEvent
```
void aTableDeleteEvent()
```

qaTableUpdatedEvent

void qaTableUpdatedEvent(EventBean theEvent)

qaTableUpdatedEventWKeyBefore

void qaTableUpdatedEventWKeyBefore(EventBean theEvent)

qaTableUpdatedEventWKeyAfter

void qaTableUpdatedEventWKeyAfter(EventBean theEvent)

Interface Instrumentation

Method Summary

Method Detail

qStimulantEvent

aStimulantEvent

qStimulantTime

aStimulantTime

qEvent

aEvent

qEventCP

aEventCP

qTime

aTime

qTimeCP

aTimeCP

qNamedWindowDispatch

aNamedWindowDispatch

qNamedWindowCPSingle

aNamedWindowCPSingle

qNamedWindowCPMulti

aNamedWindowCPMulti

qRegEx

aRegEx

qRegExState

aRegExState

qRegExStateStart

aRegExStateStart

qRegExPartition

aRegExPartition

qRegIntervalValue

aRegIntervalValue

qRegIntervalState

aRegIntervalState

qRegOut

aRegOut

qRegMeasure

aRegMeasure

qRegExScheduledEval

aRegExScheduledEval

qExprBool

aExprBool

qExprValue

aExprValue

qExprEquals

aExprEquals

qExprAnd

aExprAnd

qExprLike

aExprLike

qExprBitwise

aExprBitwise

qExprMath

aExprMath

qExprRegexp

aExprRegexp

qExprIdent

aExprIdent

qExprTypeof

aExprTypeof

qExprOr

aExprOr

qExprIn

aExprIn

qExprCoalesce

aExprCoalesce

qExprConcat

aExprConcat

qaExprConst

qaExprTimestamp

qExprBetween

aExprBetween

qExprCast

aExprCast

qExprCase

aExprCase

qExprArray

aExprArray

qExprEqualsAnyOrAll

aExprEqualsAnyOrAll

qExprMinMaxRow