public static object EvaluateChainWithWrap(
ExprDotStaticMethodWrap resultWrapLambda,
object result,
EventType optionalResultSingleEventType,
Type resultType,
ExprDotEval[] chainEval,
EventBean[] eventsPerStream,
bool newData,
ExprEvaluatorContext exprEvaluatorContext)
{
if (result == null)
{
return(null);
}
if (resultWrapLambda != null)
{
result = resultWrapLambda.Convert(result);
}
var evaluateParams = new EvaluateParams(eventsPerStream, newData, exprEvaluatorContext);
if (InstrumentationHelper.ENABLED)
{
EPType typeInfo;
if (resultWrapLambda != null)
{
typeInfo = resultWrapLambda.TypeInfo;
}
else
{
if (optionalResultSingleEventType != null)
{
typeInfo = EPTypeHelper.SingleEvent(optionalResultSingleEventType);
}
else
{
typeInfo = EPTypeHelper.SingleValue(resultType);
}
}
InstrumentationHelper.Get().QExprDotChain(typeInfo, result, chainEval);
var i = -1;
foreach (var aChainEval in chainEval)
{
i++;
InstrumentationHelper.Get().QExprDotChainElement(i, aChainEval);
result = aChainEval.Evaluate(result, evaluateParams);
InstrumentationHelper.Get().AExprDotChainElement(aChainEval.TypeInfo, result);
if (result == null)
{
break;
}
}
InstrumentationHelper.Get().AExprDotChain();
return(result);
}
foreach (var aChainEval in chainEval)
{
result = aChainEval.Evaluate(result, evaluateParams);
if (result == null)
{
return(result);
}
}
return(result);
}
public object Evaluate(EvaluateParams evaluateParams)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QExprAnd(this);
}
bool resultFlag = true;
unchecked
{
var evaluators = _evaluators;
var evaluatorsLength = evaluators.Length;
int ii = 0;
while (ii < evaluatorsLength)
{
var evaluated = evaluators[ii++].Evaluate(evaluateParams);
if (evaluated == null)
{
resultFlag = false;
break;
}
else if (false.Equals(evaluated))
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AExprAnd(false);
}
return(false);
}
}
while (ii < evaluatorsLength)
{
var evaluated = evaluators[ii++].Evaluate(evaluateParams);
if (evaluated != null && false.Equals(evaluated))
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AExprAnd(false);
}
return(false);
}
}
}
bool?result;
if (resultFlag)
{
result = true;
}
else
{
result = null;
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AExprAnd(result);
}
return(result);
}
public static EPStatementStartMethodSelectDesc Prepare(
StatementSpecCompiled statementSpec,
EPServicesContext services,
StatementContext statementContext,
bool recoveringResilient,
AgentInstanceContext defaultAgentInstanceContext,
bool queryPlanLogging,
ViewableActivatorFactory optionalViewableActivatorFactory,
OutputProcessViewCallback optionalOutputProcessViewCallback,
SelectExprProcessorDeliveryCallback selectExprProcessorDeliveryCallback)
{
// define stop and destroy
var stopCallbacks = new List <StopCallback>();
var destroyCallbacks = new EPStatementDestroyCallbackList();
// determine context
var contextName = statementSpec.OptionalContextName;
var contextPropertyRegistry = (contextName != null) ? services.ContextManagementService.GetContextDescriptor(contextName).ContextPropertyRegistry : null;
// Determine stream names for each stream - some streams may not have a name given
var streamNames = EPStatementStartMethodHelperUtil.DetermineStreamNames(statementSpec.StreamSpecs);
var numStreams = streamNames.Length;
if (numStreams == 0)
{
throw new ExprValidationException("The from-clause is required but has not been specified");
}
var isJoin = statementSpec.StreamSpecs.Length > 1;
var hasContext = statementSpec.OptionalContextName != null;
// First we create streams for subselects, if there are any
var subSelectStreamDesc = EPStatementStartMethodHelperSubselect.CreateSubSelectActivation(services, statementSpec, statementContext, destroyCallbacks);
// Create streams and views
var eventStreamParentViewableActivators = new ViewableActivator[numStreams];
var unmaterializedViewChain = new ViewFactoryChain[numStreams];
var eventTypeNames = new string[numStreams];
var isNamedWindow = new bool[numStreams];
var historicalEventViewables = new HistoricalEventViewable[numStreams];
// verify for joins that required views are present
var joinAnalysisResult = VerifyJoinViews(statementSpec, statementContext.NamedWindowMgmtService, defaultAgentInstanceContext);
var evaluatorContextStmt = new ExprEvaluatorContextStatement(statementContext, false);
for (var i = 0; i < statementSpec.StreamSpecs.Length; i++)
{
var streamSpec = statementSpec.StreamSpecs[i];
var isCanIterateUnbound = streamSpec.ViewSpecs.Length == 0 &&
(services.ConfigSnapshot.EngineDefaults.ViewResourcesConfig.IsIterableUnbound ||
AnnotationUtil.FindAttribute(statementSpec.Annotations, typeof(IterableUnboundAttribute)) != null);
// Create view factories and parent view based on a filter specification
if (streamSpec is FilterStreamSpecCompiled)
{
var filterStreamSpec = (FilterStreamSpecCompiled)streamSpec;
eventTypeNames[i] = filterStreamSpec.FilterSpec.FilterForEventTypeName;
// Since only for non-joins we get the existing stream's lock and try to reuse it's views
var filterSubselectSameStream = EPStatementStartMethodHelperUtil.DetermineSubquerySameStream(statementSpec, filterStreamSpec);
// create activator
ViewableActivator activatorDeactivator;
if (optionalViewableActivatorFactory != null)
{
activatorDeactivator = optionalViewableActivatorFactory.CreateActivatorSimple(filterStreamSpec);
if (activatorDeactivator == null)
{
throw new IllegalStateException("Viewable activate is null for " + filterStreamSpec.FilterSpec.FilterForEventType.Name);
}
}
else
{
if (!hasContext)
{
activatorDeactivator = services.ViewableActivatorFactory.CreateStreamReuseView(services, statementContext, statementSpec, filterStreamSpec, isJoin, evaluatorContextStmt, filterSubselectSameStream, i, isCanIterateUnbound);
}
else
{
InstrumentationAgent instrumentationAgentFilter = null;
if (InstrumentationHelper.ENABLED)
{
var eventTypeName = filterStreamSpec.FilterSpec.FilterForEventType.Name;
var streamNumber = i;
instrumentationAgentFilter = new ProxyInstrumentationAgent()
{
ProcIndicateQ = () => {
InstrumentationHelper.Get().QFilterActivationStream(eventTypeName, streamNumber);
},
ProcIndicateA = () => {
InstrumentationHelper.Get().AFilterActivationStream();
},
};
}
activatorDeactivator = services.ViewableActivatorFactory.CreateFilterProxy(services, filterStreamSpec.FilterSpec, statementSpec.Annotations, false, instrumentationAgentFilter, isCanIterateUnbound, i);
}
}
eventStreamParentViewableActivators[i] = activatorDeactivator;
var resultEventType = filterStreamSpec.FilterSpec.ResultEventType;
unmaterializedViewChain[i] = services.ViewService.CreateFactories(i, resultEventType, streamSpec.ViewSpecs, streamSpec.Options, statementContext, false, -1);
}
// Create view factories and parent view based on a pattern expression
else if (streamSpec is PatternStreamSpecCompiled)
{
var patternStreamSpec = (PatternStreamSpecCompiled)streamSpec;
var usedByChildViews = streamSpec.ViewSpecs.Length > 0 || (statementSpec.InsertIntoDesc != null);
var patternTypeName = statementContext.StatementId + "_pattern_" + i;
var eventType = services.EventAdapterService.CreateSemiAnonymousMapType(patternTypeName, patternStreamSpec.TaggedEventTypes, patternStreamSpec.ArrayEventTypes, usedByChildViews);
unmaterializedViewChain[i] = services.ViewService.CreateFactories(i, eventType, streamSpec.ViewSpecs, streamSpec.Options, statementContext, false, -1);
var rootFactoryNode = services.PatternNodeFactory.MakeRootNode(patternStreamSpec.EvalFactoryNode);
var patternContext = statementContext.PatternContextFactory.CreateContext(statementContext, i, rootFactoryNode, patternStreamSpec.MatchedEventMapMeta, true);
// create activator
var patternActivator = services.ViewableActivatorFactory.CreatePattern(patternContext, rootFactoryNode, eventType, EPStatementStartMethodHelperUtil.IsConsumingFilters(patternStreamSpec.EvalFactoryNode), patternStreamSpec.IsSuppressSameEventMatches, patternStreamSpec.IsDiscardPartialsOnMatch, isCanIterateUnbound);
eventStreamParentViewableActivators[i] = patternActivator;
}
// Create view factories and parent view based on a database SQL statement
else if (streamSpec is DBStatementStreamSpec)
{
ValidateNoViews(streamSpec, "Historical data");
var sqlStreamSpec = (DBStatementStreamSpec)streamSpec;
var typeConversionHook = (SQLColumnTypeConversion)TypeHelper.GetAnnotationHook(statementSpec.Annotations, HookType.SQLCOL, typeof(SQLColumnTypeConversion), statementContext.MethodResolutionService);
var outputRowConversionHook = (SQLOutputRowConversion)TypeHelper.GetAnnotationHook(statementSpec.Annotations, HookType.SQLROW, typeof(SQLOutputRowConversion), statementContext.MethodResolutionService);
var epStatementAgentInstanceHandle = defaultAgentInstanceContext.EpStatementAgentInstanceHandle;
var historicalEventViewable = DatabasePollingViewableFactory.CreateDBStatementView(
statementContext.StatementId, i, sqlStreamSpec,
services.DatabaseRefService,
services.EventAdapterService,
epStatementAgentInstanceHandle,
statementContext.Annotations,
typeConversionHook,
outputRowConversionHook,
statementContext.ConfigSnapshot.EngineDefaults.LoggingConfig.IsEnableADO,
services.DataCacheFactory,
statementContext);
historicalEventViewables[i] = historicalEventViewable;
unmaterializedViewChain[i] = ViewFactoryChain.FromTypeNoViews(historicalEventViewable.EventType);
eventStreamParentViewableActivators[i] = services.ViewableActivatorFactory.MakeHistorical(historicalEventViewable);
stopCallbacks.Add(historicalEventViewable);
}
else if (streamSpec is MethodStreamSpec)
{
ValidateNoViews(streamSpec, "Method data");
var methodStreamSpec = (MethodStreamSpec)streamSpec;
var epStatementAgentInstanceHandle = defaultAgentInstanceContext.EpStatementAgentInstanceHandle;
var historicalEventViewable = MethodPollingViewableFactory.CreatePollMethodView(
i, methodStreamSpec, services.EventAdapterService, epStatementAgentInstanceHandle,
statementContext.MethodResolutionService, services.EngineImportService,
statementContext.SchedulingService, statementContext.ScheduleBucket, evaluatorContextStmt,
statementContext.VariableService, statementContext.ContextName, services.DataCacheFactory,
statementContext);
historicalEventViewables[i] = historicalEventViewable;
unmaterializedViewChain[i] = ViewFactoryChain.FromTypeNoViews(historicalEventViewable.EventType);
eventStreamParentViewableActivators[i] = services.ViewableActivatorFactory.MakeHistorical(historicalEventViewable);
stopCallbacks.Add(historicalEventViewable);
}
else if (streamSpec is TableQueryStreamSpec)
{
ValidateNoViews(streamSpec, "Table data");
var tableStreamSpec = (TableQueryStreamSpec)streamSpec;
if (isJoin && tableStreamSpec.FilterExpressions.Count > 0)
{
throw new ExprValidationException("Joins with tables do not allow table filter expressions, please add table filters to the where-clause instead");
}
var metadata = services.TableService.GetTableMetadata(tableStreamSpec.TableName);
ExprEvaluator[] tableFilterEvals = null;
if (tableStreamSpec.FilterExpressions.Count > 0)
{
tableFilterEvals = ExprNodeUtility.GetEvaluators(tableStreamSpec.FilterExpressions);
}
EPLValidationUtil.ValidateContextName(true, metadata.TableName, metadata.ContextName, statementSpec.OptionalContextName, false);
eventStreamParentViewableActivators[i] = services.ViewableActivatorFactory.CreateTable(metadata, tableFilterEvals);
unmaterializedViewChain[i] = ViewFactoryChain.FromTypeNoViews(metadata.InternalEventType);
eventTypeNames[i] = tableStreamSpec.TableName;
joinAnalysisResult.SetTablesForStream(i, metadata);
if (tableStreamSpec.Options.IsUnidirectional)
{
throw new ExprValidationException("Tables cannot be marked as unidirectional");
}
if (tableStreamSpec.Options.IsRetainIntersection || tableStreamSpec.Options.IsRetainUnion)
{
throw new ExprValidationException("Tables cannot be marked with retain");
}
if (isJoin)
{
destroyCallbacks.AddCallback(new EPStatementDestroyCallbackTableIdxRef(services.TableService, metadata, statementContext.StatementName));
}
services.StatementVariableRefService.AddReferences(statementContext.StatementName, metadata.TableName);
}
else if (streamSpec is NamedWindowConsumerStreamSpec)
{
var namedSpec = (NamedWindowConsumerStreamSpec)streamSpec;
var processor = services.NamedWindowMgmtService.GetProcessor(namedSpec.WindowName);
var namedWindowType = processor.TailView.EventType;
if (namedSpec.OptPropertyEvaluator != null)
{
namedWindowType = namedSpec.OptPropertyEvaluator.FragmentEventType;
}
eventStreamParentViewableActivators[i] = services.ViewableActivatorFactory.CreateNamedWindow(processor, namedSpec, statementContext);
services.NamedWindowConsumerMgmtService.AddConsumer(statementContext, namedSpec);
unmaterializedViewChain[i] = services.ViewService.CreateFactories(i, namedWindowType, namedSpec.ViewSpecs, namedSpec.Options, statementContext, false, -1);
joinAnalysisResult.SetNamedWindow(i);
eventTypeNames[i] = namedSpec.WindowName;
isNamedWindow[i] = true;
// Consumers to named windows cannot declare a data window view onto the named window to avoid duplicate remove streams
EPStatementStartMethodHelperValidate.ValidateNoDataWindowOnNamedWindow(unmaterializedViewChain[i].FactoryChain);
}
else
{
throw new ExprValidationException("Unknown stream specification type: " + streamSpec);
}
}
// handle match-recognize pattern
if (statementSpec.MatchRecognizeSpec != null)
{
if (isJoin)
{
throw new ExprValidationException("Joins are not allowed when using match-recognize");
}
if (joinAnalysisResult.TablesPerStream[0] != null)
{
throw new ExprValidationException("Tables cannot be used with match-recognize");
}
var isUnbound = (unmaterializedViewChain[0].FactoryChain.IsEmpty()) && (!(statementSpec.StreamSpecs[0] is NamedWindowConsumerStreamSpec));
var factoryX = services.RegexHandlerFactory.MakeViewFactory(unmaterializedViewChain[0], statementSpec.MatchRecognizeSpec, defaultAgentInstanceContext, isUnbound, statementSpec.Annotations, services.ConfigSnapshot.EngineDefaults.MatchRecognizeConfig);
unmaterializedViewChain[0].FactoryChain.Add(factoryX);
EPStatementStartMethodHelperAssignExpr.AssignAggregations(factoryX.AggregationService, factoryX.AggregationExpressions);
}
// Obtain event types from view factory chains
var streamEventTypes = new EventType[statementSpec.StreamSpecs.Length];
for (var i = 0; i < unmaterializedViewChain.Length; i++)
{
streamEventTypes[i] = unmaterializedViewChain[i].EventType;
}
// Add uniqueness information useful for joins
joinAnalysisResult.AddUniquenessInfo(unmaterializedViewChain, statementSpec.Annotations);
// Validate sub-select views
var subSelectStrategyCollection = EPStatementStartMethodHelperSubselect.PlanSubSelect(services, statementContext, queryPlanLogging, subSelectStreamDesc, streamNames, streamEventTypes, eventTypeNames, statementSpec.DeclaredExpressions, contextPropertyRegistry);
// Construct type information per stream
StreamTypeService typeService = new StreamTypeServiceImpl(streamEventTypes, streamNames, EPStatementStartMethodHelperUtil.GetHasIStreamOnly(isNamedWindow, unmaterializedViewChain), services.EngineURI, false);
var viewResourceDelegateUnverified = new ViewResourceDelegateUnverified();
// Validate views that require validation, specifically streams that don't have
// sub-views such as DB SQL joins
var historicalViewableDesc = new HistoricalViewableDesc(numStreams);
for (var stream = 0; stream < historicalEventViewables.Length; stream++)
{
var historicalEventViewable = historicalEventViewables[stream];
if (historicalEventViewable == null)
{
continue;
}
historicalEventViewable.Validate(
services.EngineImportService,
typeService,
statementContext.MethodResolutionService,
statementContext.TimeProvider,
statementContext.VariableService, statementContext.TableService,
statementContext.ScriptingService, evaluatorContextStmt,
services.ConfigSnapshot, services.SchedulingService, services.EngineURI,
statementSpec.SqlParameters,
statementContext.EventAdapterService, statementContext);
historicalViewableDesc.SetHistorical(stream, historicalEventViewable.RequiredStreams);
if (historicalEventViewable.RequiredStreams.Contains(stream))
{
throw new ExprValidationException("Parameters for historical stream " + stream + " indicate that the stream is subordinate to itself as stream parameters originate in the same stream");
}
}
// unidirectional is not supported with into-table
if (joinAnalysisResult.IsUnidirectional && statementSpec.IntoTableSpec != null)
{
throw new ExprValidationException("Into-table does not allow unidirectional joins");
}
// Construct a processor for results posted by views and joins, which takes care of aggregation if required.
// May return null if we don't need to post-process results posted by views or joins.
var resultSetProcessorPrototypeDesc = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
statementSpec, statementContext, typeService, viewResourceDelegateUnverified, joinAnalysisResult.UnidirectionalInd, true, contextPropertyRegistry, selectExprProcessorDeliveryCallback, services.ConfigSnapshot, services.ResultSetProcessorHelperFactory, false, false);
// Validate where-clause filter tree, outer join clause and output limit expression
EPStatementStartMethodHelperValidate.ValidateNodes(statementSpec, statementContext, typeService, viewResourceDelegateUnverified);
// Handle 'prior' function nodes in terms of view requirements
var viewResourceDelegateVerified = EPStatementStartMethodHelperViewResources.VerifyPreviousAndPriorRequirements(unmaterializedViewChain, viewResourceDelegateUnverified);
// handle join
JoinSetComposerPrototype joinSetComposerPrototype = null;
if (numStreams > 1)
{
var selectsRemoveStream =
statementSpec.SelectStreamSelectorEnum.IsSelectsRStream() ||
statementSpec.OutputLimitSpec != null;
var hasAggregations = !resultSetProcessorPrototypeDesc.AggregationServiceFactoryDesc.Expressions.IsEmpty();
joinSetComposerPrototype = JoinSetComposerPrototypeFactory.MakeComposerPrototype(
statementContext.StatementName, statementContext.StatementId,
statementSpec.OuterJoinDescList, statementSpec.FilterRootNode, typeService.EventTypes, streamNames,
joinAnalysisResult, queryPlanLogging, statementContext, historicalViewableDesc, defaultAgentInstanceContext,
selectsRemoveStream, hasAggregations, services.TableService, false, services.EventTableIndexService.AllowInitIndex(recoveringResilient));
}
// obtain factory for output limiting
var outputViewFactory = OutputProcessViewFactoryFactory.Make(statementSpec, services.InternalEventRouter, statementContext, resultSetProcessorPrototypeDesc.ResultSetProcessorFactory.ResultEventType, optionalOutputProcessViewCallback, services.TableService, resultSetProcessorPrototypeDesc.ResultSetProcessorFactory.ResultSetProcessorType, services.ResultSetProcessorHelperFactory, services.StatementVariableRefService);
// Factory for statement-context instances
var factory = new StatementAgentInstanceFactorySelect(
numStreams, eventStreamParentViewableActivators,
statementContext, statementSpec, services,
typeService, unmaterializedViewChain, resultSetProcessorPrototypeDesc, joinAnalysisResult, recoveringResilient,
joinSetComposerPrototype, subSelectStrategyCollection, viewResourceDelegateVerified, outputViewFactory);
EPStatementStopMethod stopMethod = new EPStatementStopMethodImpl(statementContext, stopCallbacks);
return(new EPStatementStartMethodSelectDesc(factory, subSelectStrategyCollection, viewResourceDelegateUnverified, resultSetProcessorPrototypeDesc, stopMethod, destroyCallbacks));
}
public override void Update(EventBean[] newData, EventBean[] oldData)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewProcessIRStream(this, UnivariateStatisticsViewFactory.NAME, newData, oldData);
}
// If we have child views, keep a reference to the old values, so we can Update them as old data event.
EventBean oldDataMap = null;
if (_lastNewEvent == null)
{
if (HasViews)
{
oldDataMap = PopulateMap(_baseStatisticsBean, _agentInstanceContext.StatementContext.EventAdapterService, _viewFactory.EventType, _viewFactory.AdditionalProps, _lastValuesEventNew);
}
}
var evaluateParams = new EvaluateParams(_eventsPerStream, true, _agentInstanceContext);
// add data points to the bean
if (newData != null)
{
for (int i = 0; i < newData.Length; i++)
{
_eventsPerStream[0] = newData[i];
var pointnum = _fieldExpressionEvaluator.Evaluate(evaluateParams);
if (pointnum != null)
{
double point = pointnum.AsDouble();
_baseStatisticsBean.AddPoint(point, 0);
}
}
if ((_viewFactory.AdditionalProps != null) && (newData.Length != 0))
{
if (_lastValuesEventNew == null)
{
_lastValuesEventNew = new Object[_viewFactory.AdditionalProps.AdditionalExpr.Length];
}
for (int val = 0; val < _viewFactory.AdditionalProps.AdditionalExpr.Length; val++)
{
_lastValuesEventNew[val] = _viewFactory.AdditionalProps.AdditionalExpr[val].Evaluate(evaluateParams);
}
}
}
// remove data points from the bean
if (oldData != null)
{
for (int i = 0; i < oldData.Length; i++)
{
_eventsPerStream[0] = oldData[i];
var pointnum = _fieldExpressionEvaluator.Evaluate(evaluateParams);
if (pointnum != null)
{
double point = pointnum.AsDouble();
_baseStatisticsBean.RemovePoint(point, 0);
}
}
}
// If there are child view, call Update method
if (HasViews)
{
EventBean newDataMap = PopulateMap(_baseStatisticsBean, _agentInstanceContext.StatementContext.EventAdapterService, _viewFactory.EventType, _viewFactory.AdditionalProps, _lastValuesEventNew);
EventBean[] oldEvents;
EventBean[] newEvents = new EventBean[] { newDataMap };
if (_lastNewEvent == null)
{
oldEvents = new EventBean[] { oldDataMap };
}
else
{
oldEvents = new EventBean[] { _lastNewEvent };
}
Instrument.With(
i => i.QViewIndicate(this, UnivariateStatisticsViewFactory.NAME, newEvents, oldEvents),
i => i.AViewIndicate(),
() => UpdateChildren(newEvents, oldEvents));
_lastNewEvent = newDataMap;
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewProcessIRStream();
}
}
public override void Update(EventBean[] newData, EventBean[] oldData)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewProcessIRStream(this, UniqueByPropertyViewFactory.NAME, newData, oldData);
}
OneEventCollection postOldData = null;
if (HasViews)
{
postOldData = new OneEventCollection();
}
if (newData != null)
{
for (var i = 0; i < newData.Length; i++)
{
// Obtain unique value
var key = GetUniqueKey(newData[i]);
// If there are no child views, just update the own collection
if (!HasViews)
{
_mostRecentEvents.Put(key, newData[i]);
continue;
}
// Post the last value as old data
var lastValue = _mostRecentEvents.Get(key);
if (lastValue != null)
{
postOldData.Add(lastValue);
}
// Override with recent event
_mostRecentEvents.Put(key, newData[i]);
}
}
if (oldData != null)
{
for (var i = 0; i < oldData.Length; i++)
{
// Obtain unique value
var key = GetUniqueKey(oldData[i]);
// If the old event is the current unique event, remove and post as old data
var lastValue = _mostRecentEvents.Get(key);
if (lastValue == null || !lastValue.Equals(oldData[i]))
{
continue;
}
postOldData.Add(lastValue);
_mostRecentEvents.Remove(key);
}
}
// If there are child views, fireStatementStopped update method
if (HasViews)
{
if (postOldData.IsEmpty())
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewIndicate(this, UniqueByPropertyViewFactory.NAME, newData, null);
}
UpdateChildren(newData, null);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewIndicate();
}
}
else
{
var postOldDataArray = postOldData.ToArray();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewIndicate(this, UniqueByPropertyViewFactory.NAME, newData, postOldDataArray);
}
UpdateChildren(newData, postOldDataArray);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewIndicate();
}
}
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewProcessIRStream();
}
}
public override void Update(EventBean[] newData, EventBean[] oldData)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewProcessIRStream(this, _rankWindowViewFactory.ViewName, newData, oldData);
}
var removedEvents = new OneEventCollection();
// Remove old data
if (oldData != null)
{
for (var i = 0; i < oldData.Length; i++)
{
var uniqueKey = GetUniqueValues(oldData[i]);
var existingSortKey = _uniqueKeySortKeys.Get(uniqueKey);
if (existingSortKey == null)
{
continue;
}
var theEvent = RemoveFromSortedEvents(existingSortKey, uniqueKey);
if (theEvent != null)
{
_numberOfEvents--;
_uniqueKeySortKeys.Remove(uniqueKey);
removedEvents.Add(theEvent);
InternalHandleRemovedKey(existingSortKey, oldData[i]);
}
}
}
// Add new data
if (newData != null)
{
for (var i = 0; i < newData.Length; i++)
{
var uniqueKey = GetUniqueValues(newData[i]);
var newSortKey = GetSortValues(newData[i]);
var existingSortKey = _uniqueKeySortKeys.Get(uniqueKey);
// not currently found: its a new entry
if (existingSortKey == null)
{
CompareAndAddOrPassthru(newData[i], uniqueKey, newSortKey, removedEvents);
}
// same unique-key event found already, remove and add again
else
{
// key did not change, perform in-place substitute of event
if (existingSortKey.Equals(newSortKey))
{
var replaced = InplaceReplaceSortedEvents(existingSortKey, uniqueKey, newData[i]);
if (replaced != null)
{
removedEvents.Add(replaced);
}
InternalHandleReplacedKey(newSortKey, newData[i], replaced);
}
else
{
var removed = RemoveFromSortedEvents(existingSortKey, uniqueKey);
if (removed != null)
{
_numberOfEvents--;
removedEvents.Add(removed);
InternalHandleRemovedKey(existingSortKey, removed);
}
CompareAndAddOrPassthru(newData[i], uniqueKey, newSortKey, removedEvents);
}
}
}
}
// Remove data that sorts to the bottom of the window
if (_numberOfEvents > _sortWindowSize)
{
while (_numberOfEvents > _sortWindowSize)
{
var lastKey = _sortedEvents.Keys.Last();
var existing = _sortedEvents.Get(lastKey);
if (existing is IList <EventBean> )
{
var existingList = (IList <EventBean>)existing;
while (_numberOfEvents > _sortWindowSize && !existingList.IsEmpty())
{
var newestEvent = existingList.DeleteAt(0);
var uniqueKey = GetUniqueValues(newestEvent);
_uniqueKeySortKeys.Remove(uniqueKey);
_numberOfEvents--;
removedEvents.Add(newestEvent);
InternalHandleRemovedKey(existing, newestEvent);
}
if (existingList.IsEmpty())
{
_sortedEvents.Remove(lastKey);
}
}
else
{
var lastSortedEvent = (EventBean)existing;
var uniqueKey = GetUniqueValues(lastSortedEvent);
_uniqueKeySortKeys.Remove(uniqueKey);
_numberOfEvents--;
removedEvents.Add(lastSortedEvent);
_sortedEvents.Remove(lastKey);
InternalHandleRemovedKey(lastKey, lastSortedEvent);
}
}
}
// If there are child views, fireStatementStopped Update method
if (_optionalRankedRandomAccess != null)
{
_optionalRankedRandomAccess.Refresh(_sortedEvents, _numberOfEvents, _sortWindowSize);
}
if (HasViews)
{
EventBean[] expiredArr = null;
if (!removedEvents.IsEmpty())
{
expiredArr = removedEvents.ToArray();
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewIndicate(this, _rankWindowViewFactory.ViewName, newData, expiredArr);
}
UpdateChildren(newData, expiredArr);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewIndicate();
}
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewProcessIRStream();
}
}
public override void Update(EventBean[] newData, EventBean[] oldData)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewProcessIRStream(this, _factory.ViewName, newData, oldData);
}
// we don't care about removed data from a prior view
if ((newData == null) || (newData.Length == 0))
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewProcessIRStream();
}
return;
}
// If we have an empty window about to be filled for the first time, addSchedule a callback
bool removeSchedule = false;
bool addSchedule = false;
long timestamp = _agentInstanceContext.StatementContext.SchedulingService.Time;
if (!_currentBatch.IsEmpty())
{
// check if we need to reschedule
long callbackTime = timestamp + _timeDeltaComputation.DeltaAdd(timestamp);
if (callbackTime != _callbackScheduledTime)
{
removeSchedule = true;
addSchedule = true;
}
}
else
{
addSchedule = true;
}
if (removeSchedule)
{
_agentInstanceContext.StatementContext.SchedulingService.Remove(_handle, _scheduleSlot);
}
if (addSchedule)
{
long timeIntervalSize = _timeDeltaComputation.DeltaAdd(timestamp);
_agentInstanceContext.StatementContext.SchedulingService.Add(timeIntervalSize, _handle, _scheduleSlot);
_callbackScheduledTime = timeIntervalSize + timestamp;
}
// add data points to the window
foreach (EventBean newEvent in newData)
{
_currentBatch.Add(newEvent);
}
// forward insert stream to child views
if (_viewUpdatedCollection != null)
{
_viewUpdatedCollection.Update(newData, null);
}
// update child views
if (HasViews)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewIndicate(this, _factory.ViewName, newData, null);
}
UpdateChildren(newData, null);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewIndicate();
}
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewProcessIRStream();
}
}
public override void Update(EventBean[] newData, EventBean[] oldData)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewProcessIRStream(this, _lengthWindowViewFactory.ViewName, newData, oldData);
}
EventBean[] expiredArr = null;
if (oldData != null)
{
foreach (EventBean anOldData in oldData)
{
_indexedEvents.Remove(anOldData);
InternalHandleRemoved(anOldData);
}
if (expiredArr == null)
{
expiredArr = oldData;
}
else
{
expiredArr = CollectionUtil.AddArrayWithSetSemantics(expiredArr, oldData);
}
}
// add data points to the window
// we don't care about removed data from a prior view
if (newData != null)
{
foreach (EventBean newEvent in newData)
{
_indexedEvents.Add(newEvent);
InternalHandleAdded(newEvent);
}
}
// Check for any events that get pushed out of the window
int expiredCount = _indexedEvents.Count - _size;
if (expiredCount > 0)
{
expiredArr = _indexedEvents.Take(expiredCount).ToArray();
foreach (EventBean anExpired in expiredArr)
{
_indexedEvents.Remove(anExpired);
InternalHandleExpired(anExpired);
}
}
// If there are child views, call Update method
if (HasViews)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewIndicate(this, _lengthWindowViewFactory.ViewName, newData, expiredArr);
}
UpdateChildren(newData, expiredArr);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewIndicate();
}
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewProcessIRStream();
}
}
public override void HandleMatching(EventBean[] triggerEvents, EventBean[] matchingEvents)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QInfraOnAction(OnTriggerType.ON_SELECT, triggerEvents, matchingEvents);
}
EventBean[] newData;
// clear state from prior results
_resultSetProcessor.Clear();
// build join result
// use linked hash set to retain order of join results for last/first/window to work most intuitively
var newEvents = BuildJoinResult(triggerEvents, matchingEvents);
// process matches
var pair = _resultSetProcessor.ProcessJoinResult(newEvents, _oldEvents, false);
newData = (pair != null ? pair.First : null);
if (_parent.IsDistinct)
{
newData = EventBeanUtility.GetDistinctByProp(newData, _parent.EventBeanReader);
}
if (_tableStateInstanceInsertInto != null)
{
if (newData != null)
{
foreach (var aNewData in newData)
{
if (_audit)
{
AuditPath.AuditInsertInto(ExprEvaluatorContext.EngineURI, ExprEvaluatorContext.StatementName, aNewData);
}
_tableStateInstanceInsertInto.AddEventUnadorned(aNewData);
}
}
}
else if (_parent.InternalEventRouter != null)
{
if (newData != null)
{
foreach (var aNewData in newData)
{
if (_audit)
{
AuditPath.AuditInsertInto(ExprEvaluatorContext.EngineURI, ExprEvaluatorContext.StatementName, aNewData);
}
_parent.InternalEventRouter.Route(aNewData, _parent.StatementHandle, _parent.InternalEventRouteDest, ExprEvaluatorContext, _parent.IsAddToFront);
}
}
}
// The on-select listeners receive the events selected
if ((newData != null) && (newData.Length > 0))
{
// And post only if we have listeners/subscribers that need the data
if (_parent.StatementResultService.IsMakeNatural || _parent.StatementResultService.IsMakeSynthetic)
{
UpdateChildren(newData, null);
}
}
_lastResult = newData;
// clear state from prior results
_resultSetProcessor.Clear();
// Events to delete are indicated via old data
if (_isDelete)
{
RootView.Update(null, matchingEvents);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AInfraOnAction();
}
}
/// <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));
}
public override void Update(EventBean[] newData, EventBean[] oldData)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewProcessIRStream(this, FirstUniqueByPropertyViewFactory.NAME, newData, oldData);
}
EventBean[] newDataToPost = null;
EventBean[] oldDataToPost = null;
if (oldData != null)
{
foreach (EventBean oldEvent in oldData)
{
// Obtain unique value
object key = GetUniqueKey(oldEvent);
// If the old event is the current unique event, remove and post as old data
EventBean lastValue = _firstEvents.Get(key);
if (lastValue != oldEvent)
{
continue;
}
if (oldDataToPost == null)
{
oldDataToPost = new EventBean[] { oldEvent };
}
else
{
oldDataToPost = EventBeanUtility.AddToArray(oldDataToPost, oldEvent);
}
_firstEvents.Remove(key);
InternalHandleRemoved(key, lastValue);
}
}
if (newData != null)
{
foreach (EventBean newEvent in newData)
{
// Obtain unique value
object key = GetUniqueKey(newEvent);
// already-seen key
if (_firstEvents.ContainsKey(key))
{
continue;
}
// store
_firstEvents.Put(key, newEvent);
InternalHandleAdded(key, newEvent);
// Post the new value
if (newDataToPost == null)
{
newDataToPost = new EventBean[] { newEvent };
}
else
{
newDataToPost = EventBeanUtility.AddToArray(newDataToPost, newEvent);
}
}
}
if ((HasViews) && ((newDataToPost != null) || (oldDataToPost != null)))
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewIndicate(this, FirstUniqueByPropertyViewFactory.NAME, newDataToPost, oldDataToPost);
}
UpdateChildren(newDataToPost, oldDataToPost);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewIndicate();
}
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewProcessIRStream();
}
}
/// <summary>
/// This process (update) method is for participation in a join.
/// </summary>
/// <param name="newEvents">- new events</param>
/// <param name="oldEvents">- old events</param>
/// <param name="exprEvaluatorContext">The expr evaluator context.</param>
public override void Process(
ISet <MultiKey <EventBean> > newEvents,
ISet <MultiKey <EventBean> > oldEvents,
ExprEvaluatorContext exprEvaluatorContext)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QOutputProcessWConditionJoin(newEvents, oldEvents);
}
if ((ExecutionPathDebugLog.IsEnabled) && (Log.IsDebugEnabled))
{
Log.Debug(
".process Received update, " +
" newData.Length==" + ((newEvents == null) ? 0 : newEvents.Count) +
" oldData.Length==" + ((oldEvents == null) ? 0 : oldEvents.Count));
}
// add the incoming events to the event batches
if (_parent.HasAfter)
{
bool afterSatisfied = base.CheckAfterCondition(newEvents, _parent.StatementContext);
if (!afterSatisfied)
{
if (!_parent.IsUnaggregatedUngrouped)
{
AddToChangeset(newEvents, oldEvents, _deltaSet);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AOutputProcessWConditionJoin(false);
}
return;
}
else
{
AddToChangeset(newEvents, oldEvents, _deltaSet);
}
}
else
{
AddToChangeset(newEvents, oldEvents, _deltaSet);
}
int newEventsSize = 0;
if (newEvents != null)
{
newEventsSize = newEvents.Count;
}
int oldEventsSize = 0;
if (oldEvents != null)
{
oldEventsSize = oldEvents.Count;
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QOutputRateConditionUpdate(newEventsSize, oldEventsSize);
}
_outputCondition.UpdateOutputCondition(newEventsSize, oldEventsSize);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AOutputRateConditionUpdate();
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AOutputProcessWConditionJoin(true);
}
}
/// <summary>
/// The update method is called if the view does not participate in a join.
/// </summary>
/// <param name="newData">- new events</param>
/// <param name="oldData">- old events</param>
public override void Update(EventBean[] newData, EventBean[] oldData)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QOutputProcessWCondition(newData, oldData);
}
if ((ExecutionPathDebugLog.IsEnabled) && (Log.IsDebugEnabled))
{
Log.Debug(
".update Received update, " +
" newData.Length==" + ((newData == null) ? 0 : newData.Length) +
" oldData.Length==" + ((oldData == null) ? 0 : oldData.Length));
}
// add the incoming events to the event batches
if (_parent.HasAfter)
{
bool afterSatisfied = base.CheckAfterCondition(newData, _parent.StatementContext);
if (!afterSatisfied)
{
if (!_parent.IsUnaggregatedUngrouped)
{
_deltaSet.AddView(new UniformPair <EventBean[]>(newData, oldData));
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AOutputProcessWCondition(false);
}
return;
}
else
{
_deltaSet.AddView(new UniformPair <EventBean[]>(newData, oldData));
}
}
else
{
_deltaSet.AddView(new UniformPair <EventBean[]>(newData, oldData));
}
int newDataLength = 0;
int oldDataLength = 0;
if (newData != null)
{
newDataLength = newData.Length;
}
if (oldData != null)
{
oldDataLength = oldData.Length;
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QOutputRateConditionUpdate(newDataLength, oldDataLength);
}
_outputCondition.UpdateOutputCondition(newDataLength, oldDataLength);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AOutputRateConditionUpdate();
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AOutputProcessWCondition(true);
}
}
public override void MatchEvent(
EventBean theEvent,
ICollection<FilterHandle> matches,
ExprEvaluatorContext ctx)
{
var objAttributeValue = Lookupable.Eval.Eval(theEvent, ctx);
if (InstrumentationHelper.ENABLED) {
InstrumentationHelper.Get().QFilterReverseIndex(this, objAttributeValue);
}
if (objAttributeValue == null) {
if (InstrumentationHelper.ENABLED) {
InstrumentationHelper.Get().AFilterReverseIndex(false);
}
return;
}
var attributeValue = (string) objAttributeValue;
var rangeStart = new StringRange(null, attributeValue);
var rangeEnd = new StringRange(attributeValue, null);
var subMap = Ranges.Between(rangeStart, true, rangeEnd, true);
// For not including either endpoint
// A bit awkward to duplicate the loop code, however better than checking the boolean many times over
// This may be a bit of an early performance optimization - the optimizer after all may do this better
if (FilterOperator == FilterOperator.RANGE_OPEN) {
// include neither endpoint
foreach (var entry in subMap) {
if (string.Compare(entry.Key.Min, attributeValue, StringComparison.Ordinal) < 0 &&
string.Compare(entry.Key.Max, attributeValue, StringComparison.Ordinal) > 0) {
entry.Value.MatchEvent(theEvent, matches, ctx);
}
}
}
else if (FilterOperator == FilterOperator.RANGE_CLOSED) {
// include all endpoints
foreach (var entry in subMap) {
if (string.Compare(entry.Key.Min, attributeValue, StringComparison.Ordinal) <= 0 &&
string.Compare(entry.Key.Max, attributeValue, StringComparison.Ordinal) >= 0) {
entry.Value.MatchEvent(theEvent, matches, ctx);
}
}
}
else if (FilterOperator == FilterOperator.RANGE_HALF_CLOSED) {
// include high endpoint not low endpoint
foreach (var entry in subMap) {
if (string.Compare(entry.Key.Min, attributeValue, StringComparison.Ordinal) < 0 &&
string.Compare(entry.Key.Max, attributeValue, StringComparison.Ordinal) >= 0) {
entry.Value.MatchEvent(theEvent, matches, ctx);
}
}
}
else if (FilterOperator == FilterOperator.RANGE_HALF_OPEN) {
// include low endpoint not high endpoint
foreach (var entry in subMap) {
if (string.Compare(entry.Key.Min, attributeValue, StringComparison.Ordinal) <= 0 &&
string.Compare(entry.Key.Max, attributeValue, StringComparison.Ordinal) > 0) {
entry.Value.MatchEvent(theEvent, matches, ctx);
}
}
}
else {
throw new IllegalStateException("Invalid filter operator " + FilterOperator);
}
if (InstrumentationHelper.ENABLED) {
InstrumentationHelper.Get().AFilterReverseIndex(null);
}
}
public override void ApplyLeave(EventBean[] eventsPerStream, Object compositeGroupKey, ExprEvaluatorContext exprEvaluatorContext)
{
var evaluateParams = new EvaluateParams(eventsPerStream, false, exprEvaluatorContext);
for (var i = 0; i < Evaluators.Length; i++)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QAggregationGroupedRollupEvalParam(false, _methodParameterValues.Length);
}
_methodParameterValues[i] = Evaluators[i].Evaluate(evaluateParams);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AAggregationGroupedRollupEvalParam(_methodParameterValues[i]);
}
}
var groupKeyPerLevel = (Object[])compositeGroupKey;
for (var i = 0; i < groupKeyPerLevel.Length; i++)
{
var level = _rollupLevelDesc.Levels[i];
var groupKey = groupKeyPerLevel[i];
AggregationMethodPairRow row;
if (!level.IsAggregationTop)
{
row = _aggregatorsPerGroup[level.AggregationOffset].Get(groupKey);
}
else
{
row = _aggregatorTopGroup;
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QAggregationGroupedApplyEnterLeave(false, Aggregators.Length, _accessAggregations.Length, groupKey);
}
// The aggregators for this group do not exist, need to create them from the prototypes
AggregationMethod[] groupAggregators;
AggregationState[] groupStates;
if (row != null)
{
groupAggregators = row.Methods;
groupStates = row.States;
}
else
{
groupAggregators = _methodResolutionService.NewAggregators(Aggregators, exprEvaluatorContext.AgentInstanceId, groupKey, GroupKeyBinding, level);
groupStates = _methodResolutionService.NewAccesses(exprEvaluatorContext.AgentInstanceId, _isJoin, _accessAggregations, groupKey, GroupKeyBinding, level);
row = new AggregationMethodPairRow(_methodResolutionService.GetCurrentRowCount(groupAggregators, groupStates) + 1, groupAggregators, groupStates);
if (!level.IsAggregationTop)
{
_aggregatorsPerGroup[level.AggregationOffset].Put(groupKey, row);
}
}
// For this row, evaluate sub-expressions, enter result
_currentAggregatorMethods = groupAggregators;
_currentAggregatorStates = groupStates;
for (var j = 0; j < Evaluators.Length; j++)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QAggNoAccessEnterLeave(false, j, groupAggregators[j], Aggregators[j].AggregationExpression);
}
groupAggregators[j].Leave(_methodParameterValues[j]);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AAggNoAccessEnterLeave(false, j, groupAggregators[j]);
}
}
for (var j = 0; j < _currentAggregatorStates.Length; j++)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QAggAccessEnterLeave(false, j, _currentAggregatorStates[j], _accessAggregations[j].AggregationExpression);
}
_currentAggregatorStates[j].ApplyLeave(eventsPerStream, exprEvaluatorContext);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AAggAccessEnterLeave(false, j, _currentAggregatorStates[j]);
}
}
row.DecreaseRefcount();
if (row.Refcount <= 0)
{
_hasRemovedKey = true;
if (!level.IsAggregationTop)
{
_removedKeys[level.AggregationOffset].Add(groupKey);
}
_methodResolutionService.RemoveAggregators(exprEvaluatorContext.AgentInstanceId, groupKey, GroupKeyBinding, level); // allow persistence to remove keys already
}
InternalHandleGroupUpdate(groupKey, row, level);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AAggregationGroupedApplyEnterLeave(false);
}
}
}
public override void HandleMatching(EventBean[] triggerEvents, EventBean[] matchingEvents)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QInfraOnAction(OnTriggerType.ON_MERGE, triggerEvents, matchingEvents);
}
EventBean[] eventsPerStream = new EventBean[3]; // first:table, second: trigger, third:before-update (optional)
bool postResultsToListeners = parent.StatementResultService.IsMakeNatural || parent.StatementResultService.IsMakeSynthetic;
TableOnMergeViewChangeHandler changeHandlerRemoved = null;
TableOnMergeViewChangeHandler changeHandlerAdded = null;
if (postResultsToListeners)
{
changeHandlerRemoved = new TableOnMergeViewChangeHandler(parent.TableMetadata);
changeHandlerAdded = new TableOnMergeViewChangeHandler(parent.TableMetadata);
}
if ((matchingEvents == null) || (matchingEvents.Length == 0))
{
IList <TableOnMergeMatch> unmatched = parent.OnMergeHelper.Unmatched;
foreach (EventBean triggerEvent in triggerEvents)
{
eventsPerStream[1] = triggerEvent;
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QInfraMergeWhenThens(false, triggerEvent, unmatched.Count);
}
int count = -1;
foreach (TableOnMergeMatch action in unmatched)
{
count++;
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QInfraMergeWhenThenItem(false, count);
}
if (!action.IsApplies(eventsPerStream, base.ExprEvaluatorContext))
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AInfraMergeWhenThenItem(false, false);
}
continue;
}
action.Apply(null, eventsPerStream, TableStateInstance, changeHandlerAdded, changeHandlerRemoved, base.ExprEvaluatorContext);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AInfraMergeWhenThenItem(false, true);
}
break; // apply no other actions
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AInfraMergeWhenThens(false);
}
}
}
else
{
IList <TableOnMergeMatch> matched = parent.OnMergeHelper.Matched;
foreach (EventBean triggerEvent in triggerEvents)
{
eventsPerStream[1] = triggerEvent;
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QInfraMergeWhenThens(true, triggerEvent, matched.Count);
}
foreach (EventBean matchingEvent in matchingEvents)
{
eventsPerStream[0] = matchingEvent;
int count = -1;
foreach (TableOnMergeMatch action in matched)
{
count++;
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QInfraMergeWhenThenItem(true, count);
}
if (!action.IsApplies(eventsPerStream, base.ExprEvaluatorContext))
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AInfraMergeWhenThenItem(true, false);
}
continue;
}
action.Apply(matchingEvent, eventsPerStream, TableStateInstance, changeHandlerAdded, changeHandlerRemoved, base.ExprEvaluatorContext);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AInfraMergeWhenThenItem(true, true);
}
break; // apply no other actions
}
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AInfraMergeWhenThens(true);
}
}
}
// The on-delete listeners receive the events deleted, but only if there is interest
if (postResultsToListeners)
{
EventBean[] postedNew = changeHandlerAdded.Events;
EventBean[] postedOld = changeHandlerRemoved.Events;
if (postedNew != null || postedOld != null)
{
UpdateChildren(postedNew, postedOld);
}
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AInfraOnAction();
}
}
public override ExprNode Validate(ExprValidationContext validationContext)
{
ExprNodeUtility.Validate(ExprNodeOrigin.PLUGINSINGLEROWPARAM, _chainSpec, validationContext);
// get first chain item
var chainList = new List <ExprChainedSpec>(_chainSpec);
var firstItem = chainList.DeleteAt(0);
// Get the types of the parameters for the first invocation
var allowWildcard = validationContext.StreamTypeService.EventTypes.Length == 1;
EventType streamZeroType = null;
if (validationContext.StreamTypeService.EventTypes.Length > 0)
{
streamZeroType = validationContext.StreamTypeService.EventTypes[0];
}
var staticMethodDesc = ExprNodeUtility.ResolveMethodAllowWildcardAndStream(
_clazz.FullName, null, firstItem.Name, firstItem.Parameters, validationContext.EngineImportService,
validationContext.EventAdapterService, validationContext.StatementId, allowWildcard, streamZeroType,
new ExprNodeUtilResolveExceptionHandlerDefault(firstItem.Name, true), _functionName,
validationContext.TableService,
validationContext.StreamTypeService.EngineURIQualifier);
var allowValueCache = true;
switch (_config.ValueCache)
{
case ValueCacheEnum.DISABLED:
_isReturnsConstantResult = false;
allowValueCache = false;
break;
case ValueCacheEnum.CONFIGURED:
_isReturnsConstantResult = validationContext.EngineImportService.IsUdfCache && staticMethodDesc.IsAllConstants && chainList.IsEmpty();
allowValueCache = validationContext.EngineImportService.IsUdfCache;
break;
case ValueCacheEnum.ENABLED:
_isReturnsConstantResult = staticMethodDesc.IsAllConstants && chainList.IsEmpty();
break;
default:
throw new IllegalStateException("Invalid value cache code " + _config.ValueCache);
}
// this may return a pair of null if there is no lambda or the result cannot be wrapped for lambda-function use
var optionalLambdaWrap = ExprDotStaticMethodWrapFactory.Make(
staticMethodDesc.ReflectionMethod, validationContext.EventAdapterService, chainList,
_config.OptionalEventTypeName);
var typeInfo = optionalLambdaWrap != null ? optionalLambdaWrap.TypeInfo : EPTypeHelper.SingleValue(staticMethodDesc.ReflectionMethod.ReturnType);
var eval = ExprDotNodeUtility.GetChainEvaluators(-1, typeInfo, chainList, validationContext, false, new ExprDotNodeFilterAnalyzerInputStatic()).ChainWithUnpack;
_evaluator = new ExprDotEvalStaticMethod(
validationContext.StatementName, _clazz.FullName, staticMethodDesc.FastMethod,
staticMethodDesc.ChildEvals, allowValueCache && staticMethodDesc.IsAllConstants, optionalLambdaWrap,
eval, _config.IsRethrowExceptions, null);
// If caching the result, evaluate now and return the result.
if (_isReturnsConstantResult)
{
var result = _evaluator.Evaluate(new EvaluateParams(null, true, null));
_evaluator = new ProxyExprEvaluator
{
ProcEvaluate = args =>
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QExprPlugInSingleRow(staticMethodDesc.ReflectionMethod);
InstrumentationHelper.Get().AExprPlugInSingleRow(result);
}
return(result);
},
ReturnType = staticMethodDesc.FastMethod.ReturnType
};
}
return(null);
}
public override void Update(EventBean[] newData, EventBean[] oldData)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewProcessIRStream(this, _factory.ViewName, newData, oldData);
}
if ((newData != null) && (newData.Length > 0))
{
// If we have an empty window about to be filled for the first time, add a callback
bool removeSchedule = false;
bool addSchedule = false;
long timestamp = _agentInstanceContext.StatementContext.SchedulingService.Time;
// if the window is already filled, then we may need to reschedule
if (!_currentBatch.IsEmpty())
{
// check if we need to reschedule
long callbackTime = timestamp + _timeDeltaComputation.DeltaAdd(timestamp);
if (callbackTime != _callbackScheduledTime)
{
removeSchedule = true;
addSchedule = true;
}
}
else
{
addSchedule = true;
}
if (removeSchedule)
{
_agentInstanceContext.StatementContext.SchedulingService.Remove(_handle, _scheduleSlot);
_callbackScheduledTime = -1;
}
if (addSchedule)
{
long timeIntervalSize = _timeDeltaComputation.DeltaAdd(timestamp);
_agentInstanceContext.StatementContext.SchedulingService.Add(
timeIntervalSize, _handle, _scheduleSlot);
_callbackScheduledTime = timeIntervalSize + timestamp;
}
// add data points to the window
for (int i = 0; i < newData.Length; i++)
{
_currentBatch.Put(newData[i], timestamp);
InternalHandleAdded(newData[i], timestamp);
_lastEvent = newData[i];
}
}
if ((oldData != null) && (oldData.Length > 0))
{
bool removedLastEvent = false;
foreach (EventBean anOldData in oldData)
{
_currentBatch.Remove(anOldData);
InternalHandleRemoved(anOldData);
if (anOldData == _lastEvent)
{
removedLastEvent = true;
}
}
// we may need to reschedule as the newest event may have been deleted
if (_currentBatch.Count == 0)
{
_agentInstanceContext.StatementContext.SchedulingService.Remove(_handle, _scheduleSlot);
_callbackScheduledTime = -1;
_lastEvent = null;
}
else
{
// reschedule if the last event was removed
if (removedLastEvent)
{
var keyset = _currentBatch.Keys;
var events = keyset.ToArray();
_lastEvent = events[events.Length - 1];
long lastTimestamp = _currentBatch.Get(_lastEvent);
// reschedule, newest event deleted
long timestamp = _agentInstanceContext.StatementContext.SchedulingService.Time;
long callbackTime = lastTimestamp + _timeDeltaComputation.DeltaAdd(lastTimestamp);
long deltaFromNow = callbackTime - timestamp;
if (callbackTime != _callbackScheduledTime)
{
_agentInstanceContext.StatementContext.SchedulingService.Remove(_handle, _scheduleSlot);
_agentInstanceContext.StatementContext.SchedulingService.Add(
deltaFromNow, _handle, _scheduleSlot);
_callbackScheduledTime = callbackTime;
}
}
}
}
// update child views
if (HasViews)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewIndicate(this, _factory.ViewName, newData, oldData);
}
UpdateChildren(newData, oldData);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewIndicate();
}
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewProcessIRStream();
}
}
public override UniformPair <EventBean[]> ProcessJoinResult(ISet <MultiKey <EventBean> > newEvents, ISet <MultiKey <EventBean> > oldEvents, bool isSynthesize)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QResultSetProcessSimple();
}
EventBean[] selectOldEvents = null;
EventBean[] selectNewEvents;
if (Prototype.OptionalHavingExpr == null)
{
if (Prototype.IsSelectRStream)
{
if (_orderByProcessor == null)
{
selectOldEvents = ResultSetProcessorUtil.GetSelectJoinEventsNoHaving(_selectExprProcessor, oldEvents, false, isSynthesize, ExprEvaluatorContext);
}
else
{
selectOldEvents = ResultSetProcessorUtil.GetSelectJoinEventsNoHavingWithOrderBy(_selectExprProcessor, _orderByProcessor, oldEvents, false, isSynthesize, ExprEvaluatorContext);
}
}
if (_orderByProcessor == null)
{
selectNewEvents = ResultSetProcessorUtil.GetSelectJoinEventsNoHaving(_selectExprProcessor, newEvents, true, isSynthesize, ExprEvaluatorContext);
}
else
{
selectNewEvents = ResultSetProcessorUtil.GetSelectJoinEventsNoHavingWithOrderBy(_selectExprProcessor, _orderByProcessor, newEvents, true, isSynthesize, ExprEvaluatorContext);
}
}
else
{
if (Prototype.IsSelectRStream)
{
if (_orderByProcessor == null)
{
selectOldEvents = ResultSetProcessorUtil.GetSelectJoinEventsHaving(_selectExprProcessor, oldEvents, Prototype.OptionalHavingExpr, false, isSynthesize, ExprEvaluatorContext);
}
else
{
selectOldEvents = ResultSetProcessorUtil.GetSelectJoinEventsHavingWithOrderBy(_selectExprProcessor, _orderByProcessor, oldEvents, Prototype.OptionalHavingExpr, false, isSynthesize, ExprEvaluatorContext);
}
}
if (_orderByProcessor == null)
{
selectNewEvents = ResultSetProcessorUtil.GetSelectJoinEventsHaving(_selectExprProcessor, newEvents, Prototype.OptionalHavingExpr, true, isSynthesize, ExprEvaluatorContext);
}
else
{
selectNewEvents = ResultSetProcessorUtil.GetSelectJoinEventsHavingWithOrderBy(_selectExprProcessor, _orderByProcessor, newEvents, Prototype.OptionalHavingExpr, true, isSynthesize, ExprEvaluatorContext);
}
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AResultSetProcessSimple(selectNewEvents, selectOldEvents);
}
return(new UniformPair <EventBean[]>(selectNewEvents, selectOldEvents));
}
public override void Update(EventBean[] newData, EventBean[] oldData)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewProcessIRStream(this, _sortWindowViewFactory.ViewName, newData, oldData);
}
OneEventCollection removedEvents = null;
// Remove old data
if (oldData != null)
{
for (var i = 0; i < oldData.Length; i++)
{
var oldDataItem = oldData[i];
var sortValues = GetSortValues(oldDataItem);
var result = CollectionUtil.RemoveEventByKeyLazyListMap(sortValues, oldDataItem, _sortedEvents);
if (result)
{
_eventCount--;
if (removedEvents == null)
{
removedEvents = new OneEventCollection();
}
removedEvents.Add(oldDataItem);
InternalHandleRemoved(sortValues, oldDataItem);
}
}
}
// Add new data
if (newData != null)
{
for (var i = 0; i < newData.Length; i++)
{
var newDataItem = newData[i];
var sortValues = GetSortValues(newDataItem);
CollectionUtil.AddEventByKeyLazyListMapFront(sortValues, newDataItem, _sortedEvents);
_eventCount++;
InternalHandleAdd(sortValues, newDataItem);
}
}
// Remove data that sorts to the bottom of the window
if (_eventCount > _sortWindowSize)
{
var removeCount = _eventCount - _sortWindowSize;
for (var i = 0; i < removeCount; i++)
{
// Remove the last element of the last key - sort order is key and then natural order of arrival
var lastKey = _sortedEvents.Keys.Last();
var lastEntry = _sortedEvents.Get(lastKey);
if (lastEntry is IList <EventBean> )
{
var events = (IList <EventBean>)lastEntry;
var theEvent = events.Pluck(events.Count - 1); // remove oldest event, newest events are first in list
_eventCount--;
if (events.IsEmpty())
{
_sortedEvents.Remove(lastKey);
}
if (removedEvents == null)
{
removedEvents = new OneEventCollection();
}
removedEvents.Add(theEvent);
InternalHandleRemoved(lastKey, theEvent);
}
else
{
var theEvent = (EventBean)lastEntry;
_eventCount--;
_sortedEvents.Remove(lastKey);
if (removedEvents == null)
{
removedEvents = new OneEventCollection();
}
removedEvents.Add(theEvent);
InternalHandleRemoved(lastKey, theEvent);
}
}
}
// If there are child views, fireStatementStopped Update method
if (_optionalSortedRandomAccess != null)
{
_optionalSortedRandomAccess.Refresh(_sortedEvents, _eventCount, _sortWindowSize);
}
if (HasViews)
{
EventBean[] expiredArr = null;
if (removedEvents != null)
{
expiredArr = removedEvents.ToArray();
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewIndicate(this, _sortWindowViewFactory.ViewName, newData, expiredArr);
}
UpdateChildren(newData, expiredArr);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewIndicate();
}
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewProcessIRStream();
}
}
public void EvaluateTrue(MatchedEventMap matchEvent, EvalStateNode fromNode, bool isQuitted)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QPatternEveryDistinctEvaluateTrue(EveryNode, matchEvent);
}
// determine if this evaluation has been seen before from the same node
var matchEventKey = PatternExpressionUtil.GetKeys(matchEvent, EveryNode.FactoryNode.Convertor, EveryNode.FactoryNode.DistinctExpressionsArray, EveryNode.Context.AgentInstanceContext);
var haveSeenThis = false;
var keysFromNode = SpawnedNodes.Get(fromNode);
if (keysFromNode != null)
{
// Clean out old keys
var currentTime = EveryNode.Context.PatternContext.TimeProvider.Time;
var entries = new List <object>();
foreach (var entry in keysFromNode)
{
if (currentTime >= entry.Value)
{
entries.Add(entry.Key);
}
else
{
break;
}
}
entries.ForEach(k => keysFromNode.Remove(k));
if (keysFromNode.ContainsKey(matchEventKey))
{
haveSeenThis = true;
}
else
{
long expiryTime = EveryNode.FactoryNode.AbsMillisecondExpiry(EveryNode.Context);
keysFromNode.Put(matchEventKey, expiryTime);
}
}
if (isQuitted)
{
SpawnedNodes.Remove(fromNode);
}
// See explanation in EvalFilterStateNode for the type check
if (fromNode.IsFilterStateNode)
{
// We do not need to newState new listeners here, since the filter state node below this node did not quit
}
else
{
// Spawn all nodes below this EVERY node
// During the start of a child we need to use the temporary evaluator to catch any event created during a start
// Such events can be raised when the "not" operator is used.
var spawnEvaluator = new EvalEveryStateSpawnEvaluator(EveryNode.Context.PatternContext.StatementName);
var spawned = EveryNode.ChildNode.NewState(spawnEvaluator, null, 0L);
spawned.Start(BeginState);
// If the whole spawned expression already turned true, quit it again
if (spawnEvaluator.IsEvaluatedTrue)
{
spawned.Quit();
}
else
{
var keyset = new LinkedHashMap <Object, long>();
if (keysFromNode != null)
{
keyset.PutAll(keysFromNode);
}
SpawnedNodes.Put(spawned, keyset);
spawned.ParentEvaluator = this;
}
}
if (!haveSeenThis)
{
ParentEvaluator.EvaluateTrue(matchEvent, this, false);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().APatternEveryDistinctEvaluateTrue(null, keysFromNode, matchEventKey, haveSeenThis);
}
}
private IList <Object> CreateSortProperties(EventBean[][] generatingEvents, Object[] groupByKeys, bool isNewData, ExprEvaluatorContext exprEvaluatorContext)
{
var sortProperties = new Object[generatingEvents.Length];
var elements = _factory.OrderBy;
if (elements.Length == 1)
{
var count = 0;
foreach (var eventsPerStream in generatingEvents)
{
var evaluateParams = new EvaluateParams(eventsPerStream, isNewData, exprEvaluatorContext);
// Make a new multikey that contains the sort-by values.
if (_factory.IsNeedsGroupByKeys)
{
_aggregationService.SetCurrentAccess(groupByKeys[count], exprEvaluatorContext.AgentInstanceId, null);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QOrderBy(eventsPerStream, _factory.OrderBy);
}
sortProperties[count] = elements[0].Expr.Evaluate(evaluateParams);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AOrderBy(sortProperties[count]);
}
count++;
}
}
else
{
var count = 0;
foreach (var eventsPerStream in generatingEvents)
{
var evaluateParams = new EvaluateParams(eventsPerStream, isNewData, exprEvaluatorContext);
// Make a new multikey that contains the sort-by values.
if (_factory.IsNeedsGroupByKeys)
{
_aggregationService.SetCurrentAccess(groupByKeys[count], exprEvaluatorContext.AgentInstanceId, null);
}
var values = new Object[_factory.OrderBy.Length];
var countTwo = 0;
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QOrderBy(eventsPerStream, _factory.OrderBy);
}
foreach (var sortPair in _factory.OrderBy)
{
values[countTwo++] = sortPair.Expr.Evaluate(evaluateParams);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AOrderBy(values);
}
sortProperties[count] = new MultiKeyUntyped(values);
count++;
}
}
return(sortProperties);
}
public override void ApplyEnter(EventBean[] eventsPerStream, Object compositeGroupKey, ExprEvaluatorContext exprEvaluatorContext)
{
HandleRemovedKeys();
var evaluateParams = new EvaluateParams(eventsPerStream, true, exprEvaluatorContext);
for (var i = 0; i < Evaluators.Length; i++)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QAggregationGroupedRollupEvalParam(true, _methodParameterValues.Length);
}
_methodParameterValues[i] = Evaluators[i].Evaluate(evaluateParams);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AAggregationGroupedRollupEvalParam(_methodParameterValues[i]);
}
}
var groupKeyPerLevel = (Object[])compositeGroupKey;
for (var i = 0; i < groupKeyPerLevel.Length; i++)
{
var level = _rollupLevelDesc.Levels[i];
var groupKey = groupKeyPerLevel[i];
AggregationMethodPairRow row;
if (!level.IsAggregationTop)
{
row = _aggregatorsPerGroup[level.AggregationOffset].Get(groupKey);
}
else
{
row = _aggregatorTopGroup;
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QAggregationGroupedApplyEnterLeave(true, Aggregators.Length, _accessAggregations.Length, groupKey);
}
// The aggregators for this group do not exist, need to create them from the prototypes
AggregationMethod[] groupAggregators;
AggregationState[] groupStates;
if (row == null)
{
groupAggregators = AggSvcGroupByUtil.NewAggregators(Aggregators);
groupStates = AggSvcGroupByUtil.NewAccesses(exprEvaluatorContext.AgentInstanceId, _isJoin, _accessAggregations, groupKey, null);
row = new AggregationMethodPairRow(1, groupAggregators, groupStates);
if (!level.IsAggregationTop)
{
_aggregatorsPerGroup[level.AggregationOffset].Put(groupKey, row);
}
}
else
{
groupAggregators = row.Methods;
groupStates = row.States;
row.IncreaseRefcount();
}
// For this row, evaluate sub-expressions, enter result
_currentAggregatorMethods = groupAggregators;
_currentAggregatorStates = groupStates;
for (var j = 0; j < Evaluators.Length; j++)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QAggNoAccessEnterLeave(true, j, groupAggregators[j], Aggregators[j].AggregationExpression);
}
groupAggregators[j].Enter(_methodParameterValues[j]);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AAggNoAccessEnterLeave(true, j, groupAggregators[j]);
}
}
for (var j = 0; j < _currentAggregatorStates.Length; j++)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QAggAccessEnterLeave(true, j, _currentAggregatorStates[j], _accessAggregations[j].AggregationExpression);
}
_currentAggregatorStates[j].ApplyEnter(eventsPerStream, exprEvaluatorContext);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AAggAccessEnterLeave(true, j, _currentAggregatorStates[j]);
}
}
InternalHandleGroupUpdate(groupKey, row, level);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AAggregationGroupedApplyEnterLeave(true);
}
}
}
private IList <Object> CreateSortPropertiesWRollup(IList <GroupByRollupKey> currentGenerators, OrderByElement[][] elementsPerLevel, bool isNewData, AgentInstanceContext exprEvaluatorContext)
{
var sortProperties = new Object[currentGenerators.Count];
var elements = _factory.OrderBy;
if (elements.Length == 1)
{
var count = 0;
foreach (var rollup in currentGenerators)
{
// Make a new multikey that contains the sort-by values.
if (_factory.IsNeedsGroupByKeys)
{
_aggregationService.SetCurrentAccess(rollup.GroupKey, exprEvaluatorContext.AgentInstanceId, rollup.Level);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QOrderBy(rollup.Generator, _factory.OrderBy);
}
sortProperties[count] = elementsPerLevel[rollup.Level.LevelNumber][0].Expr.Evaluate(
new EvaluateParams(rollup.Generator, isNewData, exprEvaluatorContext));
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AOrderBy(sortProperties[count]);
}
count++;
}
}
else
{
var count = 0;
foreach (var rollup in currentGenerators)
{
var evaluateParams = new EvaluateParams(rollup.Generator, isNewData, exprEvaluatorContext);
// Make a new multikey that contains the sort-by values.
if (_factory.IsNeedsGroupByKeys)
{
_aggregationService.SetCurrentAccess(rollup.GroupKey, exprEvaluatorContext.AgentInstanceId, rollup.Level);
}
var values = new Object[_factory.OrderBy.Length];
var countTwo = 0;
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QOrderBy(rollup.Generator, _factory.OrderBy);
}
foreach (var sortPair in elementsPerLevel[rollup.Level.LevelNumber])
{
values[countTwo++] = sortPair.Expr.Evaluate(evaluateParams);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AOrderBy(values);
}
sortProperties[count] = new MultiKeyUntyped(values);
count++;
}
}
return(sortProperties);
}
public bool Handle(EventBean theEvent, ExprEvaluatorContext exprEvaluatorContext)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QSplitStream(false, theEvent, _whereClauses);
}
int index = -1;
_eventsPerStream[0] = theEvent;
for (int i = 0; i < _whereClauses.Length; i++)
{
if (_whereClauses[i] == null)
{
index = i;
break;
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QSplitStreamWhere(i);
}
var pass = (bool?)_whereClauses[i].Evaluate(new EvaluateParams(_eventsPerStream, true, exprEvaluatorContext));
if ((pass != null) && (pass.Value))
{
index = i;
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().ASplitStreamWhere(pass.Value);
}
break;
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().ASplitStreamWhere(pass.Value);
}
}
if (index != -1)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QSplitStreamRoute(index);
}
UniformPair <EventBean[]> result = _processors[index].ProcessViewResult(_eventsPerStream, null, false);
if ((result != null) && (result.First != null) && (result.First.Length > 0))
{
if (_audit)
{
AuditPath.AuditInsertInto(_agentInstanceContext.EngineURI, _agentInstanceContext.StatementName, result.First[0]);
}
if (_tableStateInstances[index] != null)
{
_tableStateInstances[index].AddEventUnadorned(result.First[0]);
}
else
{
_internalEventRouter.Route(result.First[0], _epStatementHandle, _agentInstanceContext.StatementContext.InternalEventEngineRouteDest, _agentInstanceContext, _isNamedWindowInsert[index]);
}
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().ASplitStreamRoute();
}
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().ASplitStream(false, index != -1);
}
return(index != -1);
}
public EventBean DetermineLocalMinMax(EventBean[] outgoingEvents, EventBean[][] generatingEvents, bool isNewData, ExprEvaluatorContext exprEvaluatorContext)
{
// Get the group by keys if needed
Object[] groupByKeys = null;
if (_factory.IsNeedsGroupByKeys)
{
groupByKeys = GenerateGroupKeys(generatingEvents, isNewData, exprEvaluatorContext);
}
OrderByElement[] elements = _factory.OrderBy;
Object localMinMax = null;
EventBean outgoingMinMaxBean = null;
if (elements.Length == 1)
{
int count = 0;
foreach (EventBean[] eventsPerStream in generatingEvents)
{
if (_factory.IsNeedsGroupByKeys)
{
_aggregationService.SetCurrentAccess(groupByKeys[count], exprEvaluatorContext.AgentInstanceId, null);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QOrderBy(eventsPerStream, _factory.OrderBy);
}
var evaluateParams = new EvaluateParams(eventsPerStream, isNewData, exprEvaluatorContext);
var sortKey = elements[0].Expr.Evaluate(evaluateParams);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AOrderBy(localMinMax);
}
var newMinMax = localMinMax == null || _factory.Comparator.Compare(localMinMax, sortKey) > 0;
if (newMinMax)
{
localMinMax = sortKey;
outgoingMinMaxBean = outgoingEvents[count];
}
count++;
}
}
else
{
var count = 0;
var values = new Object[_factory.OrderBy.Length];
var valuesMk = new MultiKeyUntyped(values);
foreach (var eventsPerStream in generatingEvents)
{
if (_factory.IsNeedsGroupByKeys)
{
_aggregationService.SetCurrentAccess(groupByKeys[count], exprEvaluatorContext.AgentInstanceId, null);
}
var countTwo = 0;
var evaluateParams = new EvaluateParams(eventsPerStream, isNewData, exprEvaluatorContext);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QOrderBy(eventsPerStream, _factory.OrderBy);
}
foreach (var sortPair in _factory.OrderBy)
{
values[countTwo++] = sortPair.Expr.Evaluate(evaluateParams);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AOrderBy(values);
}
var newMinMax = localMinMax == null || _factory.Comparator.Compare(localMinMax, valuesMk) > 0;
if (newMinMax)
{
localMinMax = valuesMk;
values = new Object[_factory.OrderBy.Length];
valuesMk = new MultiKeyUntyped(values);
outgoingMinMaxBean = outgoingEvents[count];
}
count++;
}
}
return(outgoingMinMaxBean);
}
public void EvaluateTrue(MatchedEventMap matchEvent, EvalStateNode fromNode, bool isQuitted)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QPatternAndEvaluateTrue(EvalAndNode, matchEvent);
}
int?indexFrom = null;
for (int i = 0; i < ActiveChildNodes.Length; i++)
{
if (ActiveChildNodes[i] == fromNode)
{
indexFrom = i;
}
}
// If one of the children quits, remove the child
if (isQuitted && indexFrom != null)
{
ActiveChildNodes[indexFrom.Value] = null;
}
if (EventsPerChild == null || indexFrom == null)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().APatternAndEvaluateTrue(true);
}
return;
}
// If all nodes have events received, the AND expression turns true
var allHaveEventsExcludingFromChild = true;
for (int i = 0; i < EventsPerChild.Length; i++)
{
if (indexFrom != i && EventsPerChild[i] == null)
{
allHaveEventsExcludingFromChild = false;
break;
}
}
// if we don't have events from all child nodes, add event and done
if (!allHaveEventsExcludingFromChild)
{
AddMatchEvent(EventsPerChild, indexFrom.Value, matchEvent);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().APatternAndEvaluateTrue(false);
}
return;
}
// if all other nodes have quit other then the from-node, don't retain matching event
var allOtherNodesQuit = true;
var hasActive = false;
for (int i = 0; i < EventsPerChild.Length; i++)
{
if (ActiveChildNodes[i] != null)
{
hasActive = true;
if (i != indexFrom)
{
allOtherNodesQuit = false;
}
}
}
// if not all other nodes have quit, add event to received list
if (!allOtherNodesQuit)
{
AddMatchEvent(EventsPerChild, indexFrom.Value, matchEvent);
}
// For each combination in eventsPerChild for all other state nodes generate an event to the parent
List <MatchedEventMap> result = GenerateMatchEvents(matchEvent, EventsPerChild, indexFrom.Value);
// Check if this is quitting
bool quitted = true;
if (hasActive)
{
foreach (EvalStateNode stateNode in ActiveChildNodes)
{
if (stateNode != null && !(stateNode.IsNotOperator))
{
quitted = false;
}
}
}
// So we are quitting if all non-not child nodes have quit, since the not-node wait for evaluate false
if (quitted)
{
QuitInternal();
}
// Send results to parent
foreach (MatchedEventMap theEvent in result)
{
ParentEvaluator.EvaluateTrue(theEvent, this, quitted);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().APatternAndEvaluateTrue(EventsPerChild == null);
}
}
public override EPStatementStartResult StartInternal(
EPServicesContext services,
StatementContext statementContext,
bool isNewStatement,
bool isRecoveringStatement,
bool isRecoveringResilient)
{
// define stop
var stopCallbacks = new List <StopCallback>();
// determine context
var contextName = _statementSpec.OptionalContextName;
// Create view factories and parent view based on a filter specification
// Since only for non-joins we get the existing stream's lock and try to reuse it's views
var filterStreamSpec = (FilterStreamSpecCompiled)_statementSpec.StreamSpecs[0];
InstrumentationAgent instrumentationAgentCreateWindowInsert = null;
if (InstrumentationHelper.ENABLED)
{
var eventTypeName = filterStreamSpec.FilterSpec.FilterForEventType.Name;
instrumentationAgentCreateWindowInsert = new ProxyInstrumentationAgent()
{
ProcIndicateQ = () => InstrumentationHelper.Get().QFilterActivationNamedWindowInsert(eventTypeName),
ProcIndicateA = () => InstrumentationHelper.Get().AFilterActivationNamedWindowInsert(),
};
}
var activator = services.ViewableActivatorFactory.CreateFilterProxy(services, filterStreamSpec.FilterSpec, statementContext.Annotations, false, instrumentationAgentCreateWindowInsert, false, 0);
// create data window view factories
var unmaterializedViewChain = services.ViewService.CreateFactories(0, filterStreamSpec.FilterSpec.ResultEventType, filterStreamSpec.ViewSpecs, filterStreamSpec.Options, statementContext, false, -1);
// verify data window
VerifyDataWindowViewFactoryChain(unmaterializedViewChain.FactoryChain);
// get processor for variant-streams and versioned typed
var windowName = _statementSpec.CreateWindowDesc.WindowName;
var optionalRevisionProcessor = statementContext.ValueAddEventService.GetValueAddProcessor(windowName);
// add named window processor (one per named window for all agent instances)
var isPrioritized = services.EngineSettingsService.EngineSettings.ExecutionConfig.IsPrioritized;
var isEnableSubqueryIndexShare = HintEnum.ENABLE_WINDOW_SUBQUERY_INDEXSHARE.GetHint(_statementSpec.Annotations) != null;
if (!isEnableSubqueryIndexShare && unmaterializedViewChain.FactoryChain[0] is VirtualDWViewFactory)
{
isEnableSubqueryIndexShare = true; // index share is always enabled for virtual data window (otherwise it wouldn't make sense)
}
var isBatchingDataWindow = DetermineBatchingDataWindow(unmaterializedViewChain.FactoryChain);
var virtualDataWindowFactory = DetermineVirtualDataWindow(unmaterializedViewChain.FactoryChain);
var optionalUniqueKeyProps = ViewServiceHelper.GetUniqueCandidateProperties(unmaterializedViewChain.FactoryChain, _statementSpec.Annotations);
var processor = services.NamedWindowMgmtService.AddProcessor(
windowName, contextName, filterStreamSpec.FilterSpec.ResultEventType,
statementContext.StatementResultService, optionalRevisionProcessor, statementContext.Expression,
statementContext.StatementName, isPrioritized, isEnableSubqueryIndexShare, isBatchingDataWindow,
virtualDataWindowFactory != null, optionalUniqueKeyProps,
_statementSpec.CreateWindowDesc.AsEventTypeName,
statementContext, services.NamedWindowDispatchService);
Viewable finalViewable;
EPStatementStopMethod stopStatementMethod;
EPStatementDestroyMethod destroyStatementMethod;
try {
// add stop callback
stopCallbacks.Add(new ProxyStopCallback(() =>
{
services.NamedWindowMgmtService.RemoveProcessor(windowName);
if (virtualDataWindowFactory != null)
{
virtualDataWindowFactory.DestroyNamedWindow();
}
}));
// Add a wildcard to the select clause as subscribers received the window contents
_statementSpec.SelectClauseSpec.SetSelectExprList(new SelectClauseElementWildcard());
_statementSpec.SelectStreamDirEnum = SelectClauseStreamSelectorEnum.RSTREAM_ISTREAM_BOTH;
// obtain result set processor factory
StreamTypeService typeService = new StreamTypeServiceImpl(new EventType[] { processor.NamedWindowType }, new string[] { windowName }, new bool[] { true }, services.EngineURI, false);
var resultSetProcessorPrototype = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
_statementSpec, statementContext, typeService, null, new bool[0], true, null, null, services.ConfigSnapshot, services.ResultSetProcessorHelperFactory, false, false);
// obtain factory for output limiting
var outputViewFactory = OutputProcessViewFactoryFactory.Make(
_statementSpec,
services.InternalEventRouter,
statementContext,
resultSetProcessorPrototype.ResultSetProcessorFactory.ResultEventType, null,
services.TableService,
resultSetProcessorPrototype.ResultSetProcessorFactory.ResultSetProcessorType,
services.ResultSetProcessorHelperFactory,
services.StatementVariableRefService);
// create context factory
// Factory for statement-context instances
var contextFactory = new StatementAgentInstanceFactoryCreateWindow(statementContext, _statementSpec, services, activator, unmaterializedViewChain, resultSetProcessorPrototype, outputViewFactory, isRecoveringStatement);
statementContext.StatementAgentInstanceFactory = contextFactory;
// With context - delegate instantiation to context
EPStatementStopMethod stopMethod = new EPStatementStopMethodImpl(statementContext, stopCallbacks);
if (_statementSpec.OptionalContextName != null)
{
var mergeView = new ContextMergeView(processor.NamedWindowType);
finalViewable = mergeView;
var statement = new ContextManagedStatementCreateWindowDesc(_statementSpec, statementContext, mergeView, contextFactory);
services.ContextManagementService.AddStatement(contextName, statement, isRecoveringResilient);
stopStatementMethod = new ProxyEPStatementStopMethod(() =>
{
services.ContextManagementService.StoppedStatement(contextName, statementContext.StatementName, statementContext.StatementId, statementContext.Expression, statementContext.ExceptionHandlingService);
stopMethod.Stop();
});
destroyStatementMethod = new ProxyEPStatementDestroyMethod(() =>
services.ContextManagementService.DestroyedStatement(contextName, statementContext.StatementName, statementContext.StatementId));
}
// Without context - start here
else
{
var agentInstanceContext = GetDefaultAgentInstanceContext(statementContext);
StatementAgentInstanceFactoryCreateWindowResult resultOfStart;
try {
resultOfStart = (StatementAgentInstanceFactoryCreateWindowResult)contextFactory.NewContext(agentInstanceContext, isRecoveringResilient);
}
catch (Exception) {
services.NamedWindowMgmtService.RemoveProcessor(windowName);
throw;
}
finalViewable = resultOfStart.FinalView;
var stopCallback = services.EpStatementFactory.MakeStopMethod(resultOfStart);
stopStatementMethod = new ProxyEPStatementStopMethod(() =>
{
stopCallback.Stop();
stopMethod.Stop();
});
destroyStatementMethod = null;
if (statementContext.StatementExtensionServicesContext != null && statementContext.StatementExtensionServicesContext.StmtResources != null)
{
var holder = statementContext.StatementExtensionServicesContext.ExtractStatementResourceHolder(resultOfStart);
statementContext.StatementExtensionServicesContext.StmtResources.Unpartitioned = holder;
statementContext.StatementExtensionServicesContext.PostProcessStart(resultOfStart, isRecoveringResilient);
}
}
}
catch (ExprValidationException) {
services.NamedWindowMgmtService.RemoveProcessor(windowName);
throw;
}
catch (Exception) {
services.NamedWindowMgmtService.RemoveProcessor(windowName);
throw;
}
services.StatementVariableRefService.AddReferences(statementContext.StatementName, windowName);
return(new EPStatementStartResult(finalViewable, stopStatementMethod, destroyStatementMethod));
}
/// <summary>
/// Pre-proces the event.
/// </summary>
/// <param name="theEvent">to pre-process</param>
/// <param name="exprEvaluatorContext">expression evaluation context</param>
/// <returns>
/// processed event
/// </returns>
public EventBean Process(EventBean theEvent, ExprEvaluatorContext exprEvaluatorContext)
{
if (_empty)
{
return(theEvent);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QUpdateIStream(_entries);
}
EventBean oldEvent = theEvent;
bool haveCloned = false;
var eventsPerStream = new EventBean[1];
eventsPerStream[0] = theEvent;
InternalEventRouterEntry lastEntry = null;
for (int i = 0; i < _entries.Length; i++)
{
InternalEventRouterEntry entry = _entries[i];
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QUpdateIStreamApply(i, entry);
}
ExprEvaluator whereClause = entry.OptionalWhereClause;
if (whereClause != null)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QUpdateIStreamApplyWhere();
}
var result = whereClause.Evaluate(new EvaluateParams(eventsPerStream, true, exprEvaluatorContext));
if ((result == null) || (false.Equals(result)))
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AUpdateIStreamApplyWhere((bool?)result);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AUpdateIStreamApply(null, false);
}
continue;
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AUpdateIStreamApplyWhere(true);
}
}
if (entry.IsDrop)
{
return(null);
}
// before applying the changes, indicate to last-entries output view
if (lastEntry != null)
{
InternalRoutePreprocessView view = lastEntry.OutputView;
if (view.IsIndicate)
{
EventBean copied = _copyMethod.Copy(theEvent);
view.Indicate(copied, oldEvent);
oldEvent = copied;
}
else
{
if (_entries[i].OutputView.IsIndicate)
{
oldEvent = _copyMethod.Copy(theEvent);
}
}
}
// copy event for the first Update that applies
if (!haveCloned)
{
EventBean copiedEvent = _copyMethod.Copy(theEvent);
if (copiedEvent == null)
{
Log.Warn("Event of type " + theEvent.EventType.Name + " could not be copied");
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AUpdateIStreamApply(null, false);
}
return(null);
}
haveCloned = true;
eventsPerStream[0] = copiedEvent;
theEvent = copiedEvent;
}
Apply(theEvent, eventsPerStream, entry, exprEvaluatorContext);
lastEntry = entry;
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AUpdateIStreamApply(theEvent, true);
}
}
if (lastEntry != null)
{
InternalRoutePreprocessView view = lastEntry.OutputView;
if (view.IsIndicate)
{
view.Indicate(theEvent, oldEvent);
}
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AUpdateIStream(theEvent, haveCloned);
}
return(theEvent);
}
public override void Update(EventBean[] newData, EventBean[] oldData)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewProcessIRStream(this, _factory.ViewName, newData, oldData);
}
// remove points from data window
if (oldData != null && oldData.Length != 0)
{
foreach (EventBean anOldData in oldData)
{
Window.Remove(anOldData);
HandleInternalRemovedEvent(anOldData);
}
DetermineOldestTimestamp();
}
// add data points to the window
EventBean[] batchNewData = null;
if (newData != null)
{
foreach (EventBean newEvent in newData)
{
long timestamp = GetLongValue(newEvent);
if (ReferenceTimestamp == null)
{
ReferenceTimestamp = timestamp;
}
if (_oldestTimestamp == null)
{
_oldestTimestamp = timestamp;
}
else
{
var delta = _timeDeltaComputation.DeltaAddWReference(
_oldestTimestamp.Value, ReferenceTimestamp.Value);
ReferenceTimestamp = delta.LastReference;
if (timestamp - _oldestTimestamp >= delta.Delta)
{
if (batchNewData == null)
{
batchNewData = Window.ToArray();
}
else
{
batchNewData = EventBeanUtility.AddToArray(batchNewData, Window);
}
Window.Clear();
_oldestTimestamp = null;
}
}
Window.Add(newEvent);
HandleInternalAddEvent(newEvent, batchNewData != null);
}
}
if (batchNewData != null)
{
HandleInternalPostBatch(Window, batchNewData);
if (ViewUpdatedCollection != null)
{
ViewUpdatedCollection.Update(batchNewData, LastBatch);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewIndicate(this, _factory.ViewName, newData, LastBatch);
}
UpdateChildren(batchNewData, LastBatch);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewIndicate();
}
LastBatch = batchNewData;
DetermineOldestTimestamp();
}
if (oldData != null && oldData.Length > 0)
{
if (ViewUpdatedCollection != null)
{
ViewUpdatedCollection.Update(null, oldData);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QViewIndicate(this, _factory.ViewName, null, oldData);
}
UpdateChildren(null, oldData);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewIndicate();
}
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AViewProcessIRStream();
}
}
