internal ViewableActivatorFilterProxy(EPServicesContext services, FilterSpecCompiled filterSpec, Attribute[] annotations, bool subSelect, InstrumentationAgent instrumentationAgent, bool isCanIterate)
{
_services = services;
_filterSpec = filterSpec;
_annotations = annotations;
_isSubSelect = subSelect;
_instrumentationAgent = instrumentationAgent;
_isCanIterate = isCanIterate;
}
public ViewableActivator CreateFilterProxy(
EPServicesContext services,
FilterSpecCompiled filterSpec,
Attribute[] annotations,
bool subselect,
InstrumentationAgent instrumentationAgentSubquery,
bool isCanIterate)
{
if (ProcCreateActivatorProxy == null)
{
throw new NotSupportedException();
}
return(ProcCreateActivatorProxy.Invoke(
services,
filterSpec,
annotations,
subselect,
instrumentationAgentSubquery,
isCanIterate));
}
public ViewableActivator CreateFilterProxy(EPServicesContext services, FilterSpecCompiled filterSpec, Attribute[] annotations, bool subselect, InstrumentationAgent instrumentationAgentSubquery, bool isCanIterate, int?streamNumFromClause)
{
return(new ViewableActivatorFilterProxy(services, filterSpec, annotations, subselect, instrumentationAgentSubquery, isCanIterate));
}
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 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));
}
