public void Activate(EventBean optionalTriggeringEvent, MatchedEventMap priorMatches, long timeOffset, bool isRecoveringResilient)
{
FilterHandleCallback filterCallback = new ProxyFilterHandleCallback
{
ProcStatementId = () => _agentInstanceContext.StatementContext.StatementId,
ProcIsSubselect = () => false,
ProcMatchFound = (theEvent, allStmtMatches) => FilterMatchFound(theEvent)
};
// determine addendum, if any
FilterValueSetParam[][] addendum = null;
if (_filterAddendum != null)
{
addendum = _filterAddendum.GetFilterAddendum(_endpointFilterSpec.FilterSpecCompiled);
}
_filterHandle = new EPStatementHandleCallback(_agentInstanceContext.EpStatementAgentInstanceHandle, filterCallback);
FilterValueSet filterValueSet = _endpointFilterSpec.FilterSpecCompiled.GetValueSet(null, _agentInstanceContext, addendum);
_filterServiceEntry = _servicesContext.FilterService.Add(filterValueSet, _filterHandle);
if (optionalTriggeringEvent != null)
{
bool match = StatementAgentInstanceUtil.EvaluateFilterForStatement(_servicesContext, optionalTriggeringEvent, _agentInstanceContext, _filterHandle);
if (match)
{
FilterMatchFound(optionalTriggeringEvent);
}
}
}
public bool Activate(
EventBean optionalTriggeringEvent,
ContextControllerEndConditionMatchEventProvider endConditionMatchEventProvider)
{
AgentInstanceContext agentInstanceContext = controller.Realization.AgentInstanceContextCreate;
FilterHandleCallback filterCallback = new ProxyFilterHandleCallback() {
ProcMatchFound = (
theEvent,
allStmtMatches) => FilterMatchFound(theEvent),
ProcIsSubselect = () => false,
};
FilterValueSetParam[][] addendum = ContextManagerUtil.ComputeAddendumNonStmt(
partitionKeys,
filter.FilterSpecActivatable,
controller.Realization);
filterHandle = new EPStatementHandleCallbackFilter(
agentInstanceContext.EpStatementAgentInstanceHandle,
filterCallback);
FilterValueSetParam[][] filterValueSet = filter.FilterSpecActivatable.GetValueSet(
null,
addendum,
agentInstanceContext,
agentInstanceContext.StatementContextFilterEvalEnv);
agentInstanceContext.FilterService.Add(
filter.FilterSpecActivatable.FilterForEventType,
filterValueSet,
filterHandle);
long filtersVersion = agentInstanceContext.FilterService.FiltersVersion;
agentInstanceContext.EpStatementAgentInstanceHandle.StatementFilterVersion.StmtFilterVersion =
filtersVersion;
bool match = false;
if (optionalTriggeringEvent != null) {
match = AgentInstanceUtil.EvaluateFilterForStatement(
optionalTriggeringEvent,
agentInstanceContext,
filterHandle);
}
return match;
}
public bool Activate(
EventBean optionalTriggeringEvent,
ContextControllerEndConditionMatchEventProvider endConditionMatchEventProvider,
IDictionary<string, object> optionalTriggeringPattern)
{
var agentInstanceContext = controller.Realization.AgentInstanceContextCreate;
FilterHandleCallback filterCallback = new ProxyFilterHandleCallback() {
ProcMatchFound = (
theEvent,
allStmtMatches) => FilterMatchFound(theEvent),
ProcIsSubselect = () => false,
};
filterHandle = new EPStatementHandleCallbackFilter(
agentInstanceContext.EpStatementAgentInstanceHandle,
filterCallback);
var filterValueSet = ComputeFilterValues(agentInstanceContext);
if (filterValueSet != null) {
agentInstanceContext.FilterService.Add(
filter.FilterSpecActivatable.FilterForEventType,
filterValueSet,
filterHandle);
var filtersVersion = agentInstanceContext.FilterService.FiltersVersion;
agentInstanceContext.EpStatementAgentInstanceHandle.StatementFilterVersion.StmtFilterVersion = filtersVersion;
}
var match = false;
if (optionalTriggeringEvent != null) {
match = AgentInstanceUtil.EvaluateFilterForStatement(
optionalTriggeringEvent,
agentInstanceContext,
filterHandle);
}
return match;
}
public ViewableActivationResult Activate(AgentInstanceContext agentInstanceContext, bool isSubselect, bool isRecoveringResilient)
{
// New event stream
EventType resultEventType = _filterSpec.ResultEventType;
EventStream zeroDepthStream = _isCanIterate ?
(EventStream) new ZeroDepthStreamIterable(resultEventType) :
(EventStream) new ZeroDepthStreamNoIterate(resultEventType);
// audit proxy
var inputStream = EventStreamProxy.GetAuditProxy(agentInstanceContext.StatementContext.EngineURI, agentInstanceContext.EpStatementAgentInstanceHandle.StatementHandle.StatementName, _annotations, _filterSpec, zeroDepthStream);
var eventStream = inputStream;
var statementId = agentInstanceContext.StatementContext.StatementId;
var filterCallback = new ProxyFilterHandleCallback
{
ProcStatementId = () => statementId,
ProcIsSubselect = () => _isSubSelect
};
if (_filterSpec.OptionalPropertyEvaluator != null)
{
filterCallback.ProcMatchFound = (theEvent, allStmtMatches) =>
{
var result = _filterSpec.OptionalPropertyEvaluator.GetProperty(theEvent, agentInstanceContext);
if (result != null)
{
eventStream.Insert(result);
}
};
}
else
{
filterCallback.ProcMatchFound = (theEvent, allStmtMatches) =>
{
if (InstrumentationHelper.ENABLED)
{
_instrumentationAgent.IndicateQ();
}
eventStream.Insert(theEvent);
if (InstrumentationHelper.ENABLED)
{
_instrumentationAgent.IndicateA();
}
};
}
var filterHandle = new EPStatementHandleCallback(agentInstanceContext.EpStatementAgentInstanceHandle, filterCallback);
FilterValueSetParam[][] addendum = null;
if (agentInstanceContext.AgentInstanceFilterProxy != null)
{
addendum = agentInstanceContext.AgentInstanceFilterProxy.GetAddendumFilters(_filterSpec);
}
var filterValueSet = _filterSpec.GetValueSet(null, agentInstanceContext, addendum);
var filterServiceEntry = _services.FilterService.Add(filterValueSet, filterHandle);
var stopCallback = new ViewableActivatorFilterProxyStopCallback(this, filterHandle, filterServiceEntry);
return(new ViewableActivationResult(inputStream, stopCallback, null, null, null, false, false, null));
}
public ViewableActivationResult Activate(
AgentInstanceContext agentInstanceContext,
bool isSubselect,
bool isRecoveringResilient)
{
FilterValueSetParam[][] addendum = null;
if (agentInstanceContext.AgentInstanceFilterProxy != null) {
addendum = agentInstanceContext.AgentInstanceFilterProxy.GetAddendumFilters(
FilterSpec,
agentInstanceContext);
}
var filterValues = FilterSpec.GetValueSet(
null,
addendum,
agentInstanceContext,
agentInstanceContext.StatementContextFilterEvalEnv);
EventStream theStream;
if (!agentInstanceContext.AuditProvider.Activated() &&
!agentInstanceContext.InstrumentationProvider.Activated()) {
theStream = CanIterate
? new ZeroDepthStreamIterable(FilterSpec.ResultEventType)
: (EventStream) new ZeroDepthStreamNoIterate(FilterSpec.ResultEventType);
}
else {
var streamNum = StreamNumFromClause ?? -1;
theStream = CanIterate
? new ZeroDepthStreamIterableWAudit(
FilterSpec.ResultEventType,
agentInstanceContext,
FilterSpec,
streamNum,
isSubselect,
SubselectNumber)
: (EventStream) new ZeroDepthStreamNoIterateWAudit(
FilterSpec.ResultEventType,
agentInstanceContext,
FilterSpec,
streamNum,
isSubselect,
SubselectNumber);
}
var statementId = agentInstanceContext.StatementId;
FilterHandleCallback filterCallback;
if (FilterSpec.OptionalPropertyEvaluator == null) {
filterCallback = new ProxyFilterHandleCallback {
ProcMatchFound = (
theEvent,
allStmtMatches) => theStream.Insert(theEvent),
ProcIsSubselect = () => IsSubSelect
};
}
else {
filterCallback = new ProxyFilterHandleCallback {
ProcMatchFound = (
theEvent,
allStmtMatches) => {
var result = FilterSpec.OptionalPropertyEvaluator.GetProperty(theEvent, agentInstanceContext);
if (result == null) {
return;
}
theStream.Insert(result);
},
ProcIsSubselect = () => IsSubSelect
};
}
var filterHandle = new EPStatementHandleCallbackFilter(
agentInstanceContext.EpStatementAgentInstanceHandle,
filterCallback);
agentInstanceContext.StatementContext.StatementContextRuntimeServices.FilterService.Add(
FilterSpec.FilterForEventType,
filterValues,
filterHandle);
var filterStopCallback = new ViewableActivatorFilterStopCallback(Container, filterHandle, FilterSpec);
return new ViewableActivationResult(theStream, filterStopCallback, null, false, false, null, null);
}
/// <summary>
/// See the method of the same name in <seealso cref="com.espertech.esper.view.stream.StreamFactoryService" />.
/// Always attempts to reuse an existing event stream. May thus return a new event stream or an existing event
/// stream depending on whether filter criteria match.
/// </summary>
/// <param name="statementId">the statement id</param>
/// <param name="filterSpec">is the filter definition</param>
/// <param name="filterService">filter service to activate filter if not already active</param>
/// <param name="epStatementAgentInstanceHandle">is the statement resource lock</param>
/// <param name="isJoin">is indicatng whether the stream will participate in a join statement, information necessary for stream reuse and multithreading concerns</param>
/// <param name="agentInstanceContext"></param>
/// <param name="hasOrderBy">if the consumer has order-by</param>
/// <param name="filterWithSameTypeSubselect">if set to <c>true</c> [filter with same type subselect].</param>
/// <param name="annotations">The annotations.</param>
/// <param name="stateless">if set to <c>true</c> [stateless].</param>
/// <param name="streamNum">The stream num.</param>
/// <param name="isCanIterateUnbound">if set to <c>true</c> [is can iterate unbound].</param>
/// <returns>
/// newly createdStatement event stream, not reusing existing instances
/// </returns>
/// <exception cref="IllegalStateException">Filter spec object already found in collection</exception>
public Pair <EventStream, IReaderWriterLock> CreateStream(
int statementId,
FilterSpecCompiled filterSpec,
FilterService filterService,
EPStatementAgentInstanceHandle epStatementAgentInstanceHandle,
bool isJoin,
AgentInstanceContext agentInstanceContext,
bool hasOrderBy,
bool filterWithSameTypeSubselect,
Attribute[] annotations,
bool stateless,
int streamNum,
bool isCanIterateUnbound)
{
EventStream eventStream;
if (Log.IsDebugEnabled)
{
Log.Debug(".createStream hashCode=" + filterSpec.GetHashCode() + " filter=" + filterSpec);
}
// Check if a stream for this filter already exists
StreamEntry entry;
var forceNewStream = isJoin || (!_isReuseViews) || hasOrderBy || filterWithSameTypeSubselect || stateless;
if (forceNewStream)
{
entry = _eventStreamsIdentity.Get(filterSpec);
}
else
{
entry = _eventStreamsRefCounted[filterSpec];
}
// If pair exists, either reference count or illegal state
if (entry != null)
{
if (forceNewStream)
{
throw new IllegalStateException("Filter spec object already found in collection");
}
else
{
Log.Debug(".createStream filter already found");
_eventStreamsRefCounted.Reference(filterSpec);
// audit proxy
eventStream = EventStreamProxy.GetAuditProxy(
_engineURI, epStatementAgentInstanceHandle.StatementHandle.StatementName, annotations,
filterSpec, entry.EventStream);
// We return the lock of the statement first establishing the stream to use that as the new statement's lock
return(new Pair <EventStream, IReaderWriterLock>(
eventStream, entry.Callback.AgentInstanceHandle.StatementAgentInstanceLock));
}
}
// New event stream
var resultEventType = filterSpec.ResultEventType;
var zeroDepthStream = isCanIterateUnbound
? (EventStream) new ZeroDepthStreamIterable(resultEventType)
: (EventStream) new ZeroDepthStreamNoIterate(resultEventType);
// audit proxy
var inputStream = EventStreamProxy.GetAuditProxy(
_engineURI, epStatementAgentInstanceHandle.StatementHandle.StatementName, annotations, filterSpec,
zeroDepthStream);
eventStream = inputStream;
FilterHandleCallback filterCallback;
if (filterSpec.OptionalPropertyEvaluator != null)
{
filterCallback = new ProxyFilterHandleCallback()
{
ProcStatementId = () => statementId,
ProcMatchFound = (theEvent, allStmtMatches) =>
{
var result = filterSpec.OptionalPropertyEvaluator.GetProperty(theEvent, agentInstanceContext);
if (result != null)
{
eventStream.Insert(result);
}
},
ProcIsSubselect = () => false
};
}
else
{
filterCallback = new ProxyFilterHandleCallback()
{
ProcStatementId = () => statementId,
ProcMatchFound = (theEvent, allStmtMatches) =>
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QFilterActivationStream(theEvent.EventType.Name, streamNum);
}
eventStream.Insert(theEvent);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AFilterActivationStream();
}
},
ProcIsSubselect = () => false
};
}
var handle = new EPStatementHandleCallback(epStatementAgentInstanceHandle, filterCallback);
// Store stream for reuse
entry = new StreamEntry(eventStream, handle);
if (forceNewStream)
{
_eventStreamsIdentity.Put(filterSpec, entry);
}
else
{
_eventStreamsRefCounted[filterSpec] = entry;
}
// Activate filter
var filterValues = filterSpec.GetValueSet(null, agentInstanceContext, null);
var filterServiceEntry = filterService.Add(filterValues, handle);
entry.FilterServiceEntry = filterServiceEntry;
return(new Pair <EventStream, IReaderWriterLock>(inputStream, null));
}
