/// <summary> /// Creates a cache implementation for the strategy as defined by the cache descriptor. /// </summary> /// <param name="cacheDesc">cache descriptor</param> /// <param name="epStatementAgentInstanceHandle">statement handle for timer invocations</param> /// <param name="schedulingService">scheduling service for time-based caches</param> /// <param name="scheduleBucket">for ordered timer invokation</param> /// <returns>data cache implementation</returns> public DataCache GetDataCache( ConfigurationDataCache cacheDesc, StatementContext statementContext, EPStatementAgentInstanceHandle epStatementAgentInstanceHandle, SchedulingService schedulingService, ScheduleBucket scheduleBucket, int streamNum) { if (cacheDesc == null) { return(new DataCacheNullImpl()); } if (cacheDesc is ConfigurationLRUCache) { var lruCache = (ConfigurationLRUCache)cacheDesc; return(new DataCacheLRUImpl(lruCache.Size)); } if (cacheDesc is ConfigurationExpiryTimeCache) { var expCache = (ConfigurationExpiryTimeCache)cacheDesc; return(MakeTimeCache(expCache, statementContext, epStatementAgentInstanceHandle, schedulingService, scheduleBucket, streamNum)); } throw new IllegalStateException("Cache implementation class not configured"); }
/// <summary>Creates a cache implementation for the strategy as defined by the cache descriptor. </summary> /// <param name="cacheDesc">cache descriptor</param> /// <param name="epStatementAgentInstanceHandle">statement handle for timer invocations</param> /// <param name="schedulingService">scheduling service for time-based caches</param> /// <param name="scheduleBucket">for ordered timer invokation</param> /// <returns>data cache implementation</returns> public static DataCache GetDataCache(ConfigurationDataCache cacheDesc, EPStatementAgentInstanceHandle epStatementAgentInstanceHandle, SchedulingService schedulingService, ScheduleBucket scheduleBucket) { if (cacheDesc == null) { return(new DataCacheNullImpl()); } if (cacheDesc is ConfigurationLRUCache) { ConfigurationLRUCache lruCache = (ConfigurationLRUCache)cacheDesc; return(new DataCacheLRUImpl(lruCache.Size)); } if (cacheDesc is ConfigurationExpiryTimeCache) { ConfigurationExpiryTimeCache expCache = (ConfigurationExpiryTimeCache)cacheDesc; return(new DataCacheExpiringImpl(expCache.MaxAgeSeconds, expCache.PurgeIntervalSeconds, expCache.CacheReferenceType, schedulingService, scheduleBucket.AllocateSlot(), epStatementAgentInstanceHandle)); } throw new IllegalStateException("Cache implementation class not configured"); }
public void HandleException( Exception ex, EPStatementAgentInstanceHandle handle, ExceptionHandlerExceptionType type) { HandleException(ex, handle.StatementHandle.StatementName, handle.StatementHandle.EPL, type); }
/// <summary>Ctor. </summary> /// <param name="services">engine services</param> /// <param name="runtime">runtime to process</param> /// <param name="handle">statement handle</param> /// <param name="callbackObject">callback list</param> public TimerUnitMultiple(EPServicesContext services, EPRuntimeImpl runtime, EPStatementAgentInstanceHandle handle, object callbackObject) { _services = services; _handle = handle; _runtime = runtime; _callbackObject = callbackObject; }
private void StartContextCallback() { var scheduleCallback = new ProxyScheduleHandleCallback { ProcScheduledTrigger = (extensionServicesContext) => { if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().QContextScheduledEval(_statementContext.ContextDescriptor); } _scheduleHandle = null; // terminates automatically unless scheduled again _callback.RangeNotification(Collections.EmptyDataMap, this, null, null, _filterAddendum); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().AContextScheduledEval(); } } }; var agentHandle = new EPStatementAgentInstanceHandle(_statementContext.EpStatementHandle, _statementContext.DefaultAgentInstanceLock, -1, new StatementAgentInstanceFilterVersion(), _statementContext.FilterFaultHandlerFactory); _scheduleHandle = new EPStatementHandleCallback(agentHandle, scheduleCallback); var schedulingService = _statementContext.SchedulingService; var engineImportService = _statementContext.EngineImportService; var nextScheduledTime = ScheduleComputeHelper.ComputeDeltaNextOccurance(_spec.Schedule, schedulingService.Time, engineImportService.TimeZone, engineImportService.TimeAbacus); _statementContext.SchedulingService.Add(nextScheduledTime, _scheduleHandle, _scheduleSlot); }
/// <summary>Processing multiple filter matches for a statement. </summary> /// <param name="handle">statement handle</param> /// <param name="callbackList">object containing callbacks</param> /// <param name="theEvent">to process</param> public void ProcessStatementFilterMultiple(EPStatementAgentInstanceHandle handle, ICollection <FilterHandleCallback> callbackList, EventBean theEvent) { using (handle.StatementAgentInstanceLock.AcquireWriteLock()) { try { if (handle.HasVariables) { _unisolatedServices.VariableService.SetLocalVersion(); } handle.MultiMatchHandler.Handle(callbackList, theEvent); // internal join processing, if applicable handle.InternalDispatch(); } catch (Exception ex) { _unisolatedServices.ExceptionHandlingService.HandleException(ex, handle); } finally { if (handle.HasTableAccess) { _unisolatedServices.TableService.TableExprEvaluatorContext.ReleaseAcquiredLocks(); } } } }
/// <summary> /// Ctor. /// </summary> /// <param name="maxAgeSec">is the maximum age in seconds</param> /// <param name="purgeIntervalSec">is the purge interval in seconds</param> /// <param name="cacheReferenceType">indicates whether hard, soft or weak references are used in the cache</param> /// <param name="schedulingService">is a service for call backs at a scheduled time, for purging</param> /// <param name="scheduleSlot">slot for scheduling callbacks for this cache</param> /// <param name="epStatementAgentInstanceHandle">is the statements-own handle for use in registering callbacks with services</param> /// <param name="timeAbacus">time abacus</param> public DataCacheExpiringImpl( double maxAgeSec, double purgeIntervalSec, ConfigurationCacheReferenceType cacheReferenceType, SchedulingService schedulingService, long scheduleSlot, EPStatementAgentInstanceHandle epStatementAgentInstanceHandle, TimeAbacus timeAbacus) { _maxAgeSec = maxAgeSec; _purgeIntervalSec = purgeIntervalSec; _schedulingService = schedulingService; _scheduleSlot = scheduleSlot; _timeAbacus = timeAbacus; if (cacheReferenceType == ConfigurationCacheReferenceType.HARD) { _cache = new Dictionary <Object, Item>(); } else if (cacheReferenceType == ConfigurationCacheReferenceType.SOFT) { _cache = new ReferenceMap <Object, Item>(ReferenceType.SOFT, ReferenceType.SOFT); } else { _cache = new WeakDictionary <Object, Item>(); } _epStatementAgentInstanceHandle = epStatementAgentInstanceHandle; }
/// <summary>Ctor. </summary> /// <param name="maxAgeSec">is the maximum age in seconds</param> /// <param name="purgeIntervalSec">is the purge interval in seconds</param> /// <param name="cacheReferenceType">indicates whether hard, soft or weak references are used in the cache</param> /// <param name="schedulingService">is a service for call backs at a scheduled time, for purging</param> /// <param name="scheduleSlot">slot for scheduling callbacks for this cache</param> /// <param name="epStatementAgentInstanceHandle">is the statements-own handle for use in registering callbacks with services</param> public DataCacheExpiringImpl(double maxAgeSec, double purgeIntervalSec, ConfigurationCacheReferenceType cacheReferenceType, SchedulingService schedulingService, long scheduleSlot, EPStatementAgentInstanceHandle epStatementAgentInstanceHandle) { MaxAgeMSec = (long)maxAgeSec * 1000; PurgeIntervalMSec = (long)purgeIntervalSec * 1000; _schedulingService = schedulingService; _scheduleSlot = scheduleSlot; if (cacheReferenceType == ConfigurationCacheReferenceType.HARD) { _cache = new Dictionary <Object, Item>(); } else if (cacheReferenceType == ConfigurationCacheReferenceType.SOFT) { _cache = new ReferenceMap <Object, Item>(ReferenceType.SOFT, ReferenceType.SOFT); } else { _cache = new WeakDictionary <Object, Item>(); } _epStatementAgentInstanceHandle = epStatementAgentInstanceHandle; }
public void TestDropNoJoin() { var stmtHande = new EPStatementHandle(1, "id", null, StatementType.SELECT, "text", false, null, 1, false, false, new MultiMatchHandlerFactoryImpl().GetDefaultHandler()); var stmtAgentHandle = new EPStatementAgentInstanceHandle(stmtHande, ReaderWriterLockManager.CreateDefaultLock(), -1, null, null); _streams = new EventStream[4]; _streams[0] = _streamFactoryService.CreateStream(1, _filterSpecs[0], _supportFilterService, stmtAgentHandle, false, null, false, false, null, false, 0, false).First; _streams[1] = _streamFactoryService.CreateStream(2, _filterSpecs[0], _supportFilterService, stmtAgentHandle, false, null, false, false, null, false, 0, false).First; _streams[2] = _streamFactoryService.CreateStream(3, _filterSpecs[1], _supportFilterService, stmtAgentHandle, false, null, false, false, null, false, 0, false).First; _streams[3] = _streamFactoryService.CreateStream(4, _filterSpecs[2], _supportFilterService, stmtAgentHandle, false, null, false, false, null, false, 0, false).First; _streamFactoryService.DropStream(_filterSpecs[0], _supportFilterService, false, false, false, false); _streamFactoryService.DropStream(_filterSpecs[1], _supportFilterService, false, false, false, false); Assert.AreEqual(0, _supportFilterService.Removed.Count); // Filter removed _streamFactoryService.DropStream(_filterSpecs[0], _supportFilterService, false, false, false, false); Assert.AreEqual(1, _supportFilterService.Removed.Count); _streamFactoryService.DropStream(_filterSpecs[2], _supportFilterService, false, false, false, false); Assert.AreEqual(2, _supportFilterService.Removed.Count); // Something already removed try { _streamFactoryService.DropStream(_filterSpecs[2], _supportFilterService, false, false, false, false); Assert.Fail(); } catch (IllegalStateException) { // Expected } }
public void QNamedWindowCPMulti( string runtimeURI, IDictionary<NamedWindowConsumerView, NamedWindowDeltaData> deltaPerConsumer, EPStatementAgentInstanceHandle handle, long time) { }
/// <summary> /// Called by the consumer view to indicate it was stopped or destroyed, such that the /// consumer can be deregistered and further dispatches disregard this consumer. /// </summary> public void RemoveConsumer(NamedWindowConsumerView namedWindowConsumerView) { EPStatementAgentInstanceHandle handleRemoved = null; // Find the consumer view foreach (var entry in _consumersInContext) { var foundAndRemoved = entry.Value.Remove(namedWindowConsumerView); // Remove the consumer view if (foundAndRemoved && entry.Value.IsEmpty()) { // Remove the handle if this list is now empty handleRemoved = entry.Key; break; } } if (handleRemoved != null) { var newConsumers = NamedWindowUtil.CreateConsumerMap(TailView.IsPrioritized); newConsumers.PutAll(_consumersInContext); newConsumers.Remove(handleRemoved); _consumersInContext = newConsumers; } // indicate to virtual data window that a consumer was added var virtualDWView = _rootViewInstance.VirtualDataWindow; if (virtualDWView != null && handleRemoved != null) { virtualDWView.VirtualDataWindow.HandleEvent( new VirtualDataWindowEventConsumerRemove( TailView.EventType.Name, namedWindowConsumerView, handleRemoved.StatementHandle.StatementName, handleRemoved.AgentInstanceId)); } }
public void Open(DataFlowOpOpenContext openContext) { FilterValueSet valueSet; try { IList <ExprNode> filters = new ExprNode[0]; if (filter != null) { filters = new ExprNode[] { filter }; } var spec = FilterSpecCompiler.MakeFilterSpec( _eventType, _eventType.Name, filters, null, null, null, new StreamTypeServiceImpl( _eventType, _eventType.Name, true, _agentInstanceContext.EngineURI), null, _agentInstanceContext.StatementContext, new List <int>()); valueSet = spec.GetValueSet(null, _agentInstanceContext, null); } catch (ExprValidationException ex) { throw new EPException("Failed to open filter: " + ex.Message, ex); } var handle = new EPStatementAgentInstanceHandle(_agentInstanceContext.StatementContext.EpStatementHandle, _agentInstanceContext.AgentInstanceLock, 0, new StatementAgentInstanceFilterVersion()); _callbackHandle = new EPStatementHandleCallback(handle, this); _filterServiceEntry = _agentInstanceContext.StatementContext.FilterService.Add(valueSet, _callbackHandle); }
private void StartContextCallback(long timeOffset) { var scheduleCallback = new ProxyScheduleHandleCallback() { ProcScheduledTrigger = extensionServicesContext => { if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().QContextScheduledEval(_agentInstanceContext.StatementContext.ContextDescriptor); } _scheduleHandle = null; // terminates automatically unless scheduled again _callback.RangeNotification(Collections.GetEmptyMap <String, Object>(), this, null, null, _filterAddendum); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().AContextScheduledEval(); } } }; var agentHandle = new EPStatementAgentInstanceHandle( _agentInstanceContext.StatementContext.EpStatementHandle, _agentInstanceContext.StatementContext.DefaultAgentInstanceLock, -1, new StatementAgentInstanceFilterVersion(), _agentInstanceContext.StatementContext.FilterFaultHandlerFactory); _scheduleHandle = new EPStatementHandleCallback(agentHandle, scheduleCallback); long timeDelta = _spec.TimePeriod.NonconstEvaluator().DeltaUseEngineTime(null, _agentInstanceContext) - timeOffset; _agentInstanceContext.StatementContext.SchedulingService.Add(timeDelta, _scheduleHandle, _scheduleSlot); }
/// <summary>Process a single match. </summary> /// <param name="handle">statement</param> /// <param name="handleCallback">callback</param> /// <param name="theEvent">event to indicate</param> public void ProcessStatementFilterSingle(EPStatementAgentInstanceHandle handle, EPStatementHandleCallback handleCallback, EventBean theEvent) { using (handle.StatementAgentInstanceLock.AcquireWriteLock()) { try { if (handle.HasVariables) { _unisolatedServices.VariableService.SetLocalVersion(); } handleCallback.FilterCallback.MatchFound(theEvent, null); // internal join processing, if applicable handle.InternalDispatch(); } catch (Exception ex) { _unisolatedServices.ExceptionHandlingService.HandleException(ex, handle, ExceptionHandlerExceptionType.PROCESS, theEvent); } finally { if (handle.HasTableAccess) { _unisolatedServices.TableService.TableExprEvaluatorContext.ReleaseAcquiredLocks(); } } } }
private void ScheduleNextCallback() { var nextScheduleCallback = new ProxyScheduleHandleCallback(delegate { ContinueSendingEvents(); }); var spi = (EPServiceProviderSPI)_epService; var metricsHandle = spi.MetricReportingService.GetStatementHandle(-1, "AbstractCoordinatedAdapter"); var lockImpl = ReaderWriterLockManager.CreateLock("CSV"); var stmtHandle = new EPStatementHandle(-1, "AbstractCoordinatedAdapter", null, StatementType.ESPERIO, "AbstractCoordinatedAdapter", false, metricsHandle, 0, false, false, spi.ServicesContext.MultiMatchHandlerFactory.GetDefaultHandler()); var agentInstanceHandle = new EPStatementAgentInstanceHandle(stmtHandle, lockImpl, -1, new StatementAgentInstanceFilterVersion(), null); var scheduleCSVHandle = new EPStatementHandleCallback(agentInstanceHandle, nextScheduleCallback); ScheduleSlot nextScheduleSlot; if (EventsToSend.IsEmpty()) { if ((ExecutionPathDebugLog.IsEnabled) && (Log.IsDebugEnabled)) { Log.Debug(".scheduleNextCallback no events to send, scheduling callback in 100 ms"); } nextScheduleSlot = new ScheduleSlot(0, 0); _schedulingService.Add(100, scheduleCSVHandle, nextScheduleSlot); } else { // Offset is not a function of the currentTime alone. var first = EventsToSend.First(); long baseMsec = _currentTime - _startTime; long afterMsec = first.SendTime - baseMsec; nextScheduleSlot = first.ScheduleSlot; if ((ExecutionPathDebugLog.IsEnabled) && (Log.IsDebugEnabled)) { Log.Debug(".scheduleNextCallback schedulingCallback in " + afterMsec + " milliseconds"); } _schedulingService.Add(afterMsec, scheduleCSVHandle, nextScheduleSlot); } }
/// <summary>Ctor. </summary> /// <param name="epRuntime">runtime to process</param> /// <param name="callbackList">callback list</param> /// <param name="theEvent">event to pass</param> /// <param name="handle">statement handle</param> /// <param name="filterVersion">version of filter</param> public RouteUnitMultiple(EPRuntimeImpl epRuntime, Object callbackList, EventBean theEvent, EPStatementAgentInstanceHandle handle, long filterVersion) { _epRuntime = epRuntime; _callbackList = callbackList; _theEvent = theEvent; _handle = handle; _filterVersion = filterVersion; }
public void HandleException( Exception ex, EPStatementAgentInstanceHandle handle, ExceptionHandlerExceptionType type, EventBean optionalCurrentEvent) { HandleException(ex, handle.StatementHandle.StatementName, handle.StatementHandle.EPL, type, optionalCurrentEvent); }
/// <summary> /// Ctor. /// </summary> /// <param name="epRuntime">runtime to process</param> /// <param name="callbackList">callback list</param> /// <param name="theEvent">event to pass</param> /// <param name="handle">statement handle</param> /// <param name="filterVersion">version of filter</param> public RouteUnitMultiple(EPEventServiceImpl epRuntime, object callbackList, EventBean theEvent, EPStatementAgentInstanceHandle handle, long filterVersion) { this.epRuntime = epRuntime; this.callbackList = callbackList; this.theEvent = theEvent; this.handle = handle; this.filterVersion = filterVersion; }
public void QNamedWindowCPSingle( string runtimeURI, int numConsumers, EventBean[] newData, EventBean[] oldData, EPStatementAgentInstanceHandle handle, long time) { }
/// <summary> /// Ctor. /// </summary> /// <param name="services">runtime services</param> /// <param name="runtime">runtime to process</param> /// <param name="handle">statement handle</param> /// <param name="callbackObject">callback list</param> public TimerUnitMultiple( EPServicesContext services, EPEventServiceImpl runtime, EPStatementAgentInstanceHandle handle, object callbackObject) { this.services = services; this.handle = handle; this.runtime = runtime; this.callbackObject = callbackObject; }
/// <summary> /// Ctor. /// </summary> /// <param name="services">runtime services</param> /// <param name="runtime">runtime to process</param> /// <param name="handle">statement handle</param> /// <param name="callbackObject">callback list</param> public TimerUnitMultipleStaged( StageSpecificServices services, EPStageEventServiceImpl runtime, EPStatementAgentInstanceHandle handle, object callbackObject) { this.services = services; this.handle = handle; this.runtime = runtime; this.callbackObject = callbackObject; }
/// <summary> /// Processing multiple schedule matches for a statement. /// </summary> /// <param name="handle">statement handle</param> /// <param name="callbackObject">object containing matches</param> /// <param name="services">runtime services</param> public static void ProcessStatementScheduleMultiple( EPStatementAgentInstanceHandle handle, object callbackObject, EPServicesEvaluation services) { if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().QTimeCP(handle, services.SchedulingService.Time); } handle.StatementAgentInstanceLock.AcquireWriteLock(); try { if (!handle.IsDestroyed) { if (handle.HasVariables) { services.VariableManagementService.SetLocalVersion(); } if (callbackObject is ArrayDeque <ScheduleHandleCallback> ) { ArrayDeque <ScheduleHandleCallback> callbackList = (ArrayDeque <ScheduleHandleCallback>)callbackObject; foreach (ScheduleHandleCallback callback in callbackList) { callback.ScheduledTrigger(); } } else { ScheduleHandleCallback callback = (ScheduleHandleCallback)callbackObject; callback.ScheduledTrigger(); } // internal join processing, if applicable handle.InternalDispatch(); } } catch (Exception ex) { services.ExceptionHandlingService.HandleException(ex, handle, ExceptionHandlerExceptionType.PROCESS, null); } finally { if (handle.HasTableAccess) { services.TableExprEvaluatorContext.ReleaseAcquiredLocks(); } handle.StatementAgentInstanceLock.ReleaseWriteLock(); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().ATimeCP(); } } }
protected internal DataCache MakeTimeCache( ConfigurationExpiryTimeCache expCache, StatementContext statementContext, EPStatementAgentInstanceHandle epStatementAgentInstanceHandle, SchedulingService schedulingService, ScheduleBucket scheduleBucket, int streamNum) { return(new DataCacheExpiringImpl( expCache.MaxAgeSeconds, expCache.PurgeIntervalSeconds, expCache.CacheReferenceType, schedulingService, scheduleBucket.AllocateSlot(), epStatementAgentInstanceHandle)); }
public void HandleException(Exception ex, EPStatementAgentInstanceHandle handle) { if (UnhandledException == null) { Log.Error(string.Format("Exception encountered processing statement '{0}' statement text '{1}' : {2}", handle.StatementHandle.StatementName, handle.StatementHandle.EPL, ex.Message), ex); return; } UnhandledException( new ExceptionHandlerContext( _engineURI, ex, handle.StatementHandle.StatementName, handle.StatementHandle.EPL)); }
/// <summary> /// Returns a new cache implementation for this database. /// </summary> /// <param name="databaseName">the name of the database to return a new cache implementation for for</param> /// <param name="epStatementAgentInstanceHandle">is the statements-own handle for use in registering callbacks with services</param> /// <returns>cache implementation</returns> /// <throws> DatabaseConfigException is thrown to indicate database configuration errors </throws> public virtual DataCache GetDataCache(String databaseName, EPStatementAgentInstanceHandle epStatementAgentInstanceHandle) { ConfigurationDBRef config; if (!_mapDatabaseRef.TryGetValue(databaseName, out config)) { throw new DatabaseConfigException("Cannot locate configuration information for database '" + databaseName + "'"); } ConfigurationDataCache dataCacheDesc = config.DataCacheDesc; return(DataCacheFactory.GetDataCache(dataCacheDesc, epStatementAgentInstanceHandle, _schedulingService, _scheduleBucket)); }
/// <summary>Register an adapter. </summary> /// <param name="epService">engine</param> public void RegisterAdapter(EPServiceProvider epService) { var spi = (EPServiceProviderSPI)epService; var eventType = spi.EventAdapterService.GetEventTypeByName(EventTypeName); var fvs = new FilterSpecCompiled(eventType, null, new IList <FilterSpecParam> [0], null).GetValueSet(null, null, null); var name = "subscription:" + SubscriptionName; var metricsHandle = spi.MetricReportingService.GetStatementHandle(name, name); var statementHandle = new EPStatementHandle(name, name, name, StatementType.ESPERIO, name, false, metricsHandle, 0, false, false, MultiMatchHandlerFactory.DefaultHandler); var agentHandle = new EPStatementAgentInstanceHandle(statementHandle, ReaderWriterLockManager.CreateDefaultLock(), -1, new StatementAgentInstanceFilterVersion()); var registerHandle = new EPStatementHandleCallback(agentHandle, this); spi.FilterService.Add(fvs, registerHandle); }
public void SetUp() { _container = SupportContainer.Reset(); _handle = new EPStatementHandle(1, "name", "text", StatementType.SELECT, "text", false, null, 1, false, false, new MultiMatchHandlerFactoryImpl().GetDefaultHandler()); _agentHandle = new EPStatementAgentInstanceHandle(_handle, _container.RWLockManager().CreateDefaultLock(), -1, null, null); _supportFilterService = new SupportFilterServiceImpl(); _streamFactoryService = new StreamFactorySvcImpl("default", true); var eventType = SupportEventTypeFactory.CreateBeanType(typeof(SupportBean)); _filterSpecs = new FilterSpecCompiled[3]; _filterSpecs[0] = SupportFilterSpecBuilder.Build(eventType, new Object[] { "string", FilterOperator.EQUAL, "a" }); _filterSpecs[1] = SupportFilterSpecBuilder.Build(eventType, new Object[] { "string", FilterOperator.EQUAL, "a" }); _filterSpecs[2] = SupportFilterSpecBuilder.Build(eventType, new Object[] { "string", FilterOperator.EQUAL, "b" }); }
private void ProcessHandleMultiple(EPStatementAgentInstanceHandle handle, IDictionary <NamedWindowConsumerView, NamedWindowDeltaData> deltaPerConsumer) { if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().QNamedWindowCPMulti(_exceptionHandlingService.EngineURI, deltaPerConsumer, handle, _schedulingService.Time); } try { using (handle.StatementAgentInstanceLock.AcquireWriteLock()) { try { if (handle.HasVariables) { _variableService.SetLocalVersion(); } foreach (var entryDelta in deltaPerConsumer) { var newData = entryDelta.Value.NewData; var oldData = entryDelta.Value.OldData; entryDelta.Key.Update(newData, oldData); } // internal join processing, if applicable handle.InternalDispatch(); } catch (Exception ex) { _exceptionHandlingService.HandleException(ex, handle, ExceptionHandlerExceptionType.PROCESS); } finally { if (handle.HasTableAccess) { _tableService.TableExprEvaluatorContext.ReleaseAcquiredLocks(); } } } } finally { if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().ANamedWindowCPMulti(); } } }
public override ICollection <EventBean> GetSnapshot(EPStatementAgentInstanceHandle createWindowStmtHandle, Viewable parent) { using (createWindowStmtHandle.StatementAgentInstanceLock.AcquireReadLock()) { var it = parent.GetEnumerator(); var list = new LinkedList <EventBean>(); while (it.MoveNext()) { var fullRevision = (RevisionEventBeanDeclared)it.Current; var key = fullRevision.Key; var state = _statePerKey.Get(key); list.AddLast(state.LastEvent); } return(list); } }
private void ProcessHandle(EPStatementAgentInstanceHandle handle, IList <NamedWindowConsumerView> value, EventBean[] newData, EventBean[] oldData) { if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().QNamedWindowCPSingle(_exceptionHandlingService.EngineURI, value, newData, oldData, handle, _schedulingService.Time); } try { using (handle.StatementAgentInstanceLock.AcquireWriteLock()) { try { if (handle.HasVariables) { _variableService.SetLocalVersion(); } foreach (var consumerView in value) { consumerView.Update(newData, oldData); } // internal join processing, if applicable handle.InternalDispatch(); } catch (Exception ex) { _exceptionHandlingService.HandleException(ex, handle, ExceptionHandlerExceptionType.PROCESS); } finally { if (handle.HasTableAccess) { _tableService.TableExprEvaluatorContext.ReleaseAcquiredLocks(); } } } } finally { if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().ANamedWindowCPSingle(); } } }