public override EPStatementStartResult StartInternal(EPServicesContext services, StatementContext statementContext, bool isNewStatement, bool isRecoveringStatement, bool isRecoveringResilient)
{
// define stop and destroy
var stopCallbacks = new List <StopCallback>();
var destroyCallbacks = new EPStatementDestroyCallbackList();
// determine context
var contextName = StatementSpec.OptionalContextName;
if (contextName != null)
{
throw new ExprValidationException("Update IStream is not supported in conjunction with a context");
}
// First we create streams for subselects, if there are any
var subSelectStreamDesc = EPStatementStartMethodHelperSubselect.CreateSubSelectActivation(
services, StatementSpec, statementContext, destroyCallbacks);
var streamSpec = StatementSpec.StreamSpecs[0];
var updateSpec = StatementSpec.UpdateSpec;
String triggereventTypeName;
if (streamSpec is FilterStreamSpecCompiled)
{
var filterStreamSpec = (FilterStreamSpecCompiled)streamSpec;
triggereventTypeName = filterStreamSpec.FilterSpec.FilterForEventTypeName;
}
else if (streamSpec is NamedWindowConsumerStreamSpec)
{
var namedSpec = (NamedWindowConsumerStreamSpec)streamSpec;
triggereventTypeName = namedSpec.WindowName;
}
else if (streamSpec is TableQueryStreamSpec)
{
throw new ExprValidationException("Tables cannot be used in an update-istream statement");
}
else
{
throw new ExprValidationException("Unknown stream specification streamEventType: " + streamSpec);
}
// determine a stream name
var streamName = triggereventTypeName;
if (updateSpec.OptionalStreamName != null)
{
streamName = updateSpec.OptionalStreamName;
}
var streamEventType = services.EventAdapterService.GetEventTypeByName(triggereventTypeName);
StreamTypeService typeService = new StreamTypeServiceImpl(new EventType[] { streamEventType }, new String[] { streamName }, new bool[] { true }, services.EngineURI, false);
// determine subscriber result types
var evaluatorContextStmt = new ExprEvaluatorContextStatement(statementContext, false);
statementContext.StatementResultService.SetSelectClause(new Type[] { streamEventType.UnderlyingType }, new String[] { "*" }, false, null, evaluatorContextStmt);
// Materialize sub-select views
var subSelectStrategyCollection = EPStatementStartMethodHelperSubselect.PlanSubSelect(services, statementContext, IsQueryPlanLogging(services), subSelectStreamDesc, new String[] { streamName }, new EventType[] { streamEventType }, new String[] { triggereventTypeName }, StatementSpec.DeclaredExpressions, null);
var validationContext = new ExprValidationContext(
typeService,
statementContext.MethodResolutionService, null,
statementContext.SchedulingService,
statementContext.VariableService,
statementContext.TableService,
evaluatorContextStmt,
statementContext.EventAdapterService,
statementContext.StatementName,
statementContext.StatementId,
statementContext.Annotations,
statementContext.ContextDescriptor,
statementContext.ScriptingService,
false, false, false, false,
null, false);
foreach (var assignment in updateSpec.Assignments)
{
var validated = ExprNodeUtility.GetValidatedAssignment(assignment, validationContext);
assignment.Expression = validated;
EPStatementStartMethodHelperValidate.ValidateNoAggregations(validated, "Aggregation functions may not be used within an update-clause");
}
if (updateSpec.OptionalWhereClause != null)
{
var validated = ExprNodeUtility.GetValidatedSubtree(
ExprNodeOrigin.WHERE, updateSpec.OptionalWhereClause, validationContext);
updateSpec.OptionalWhereClause = validated;
EPStatementStartMethodHelperValidate.ValidateNoAggregations(validated, "Aggregation functions may not be used within an update-clause");
}
// preprocessing view
var onExprView = new InternalRoutePreprocessView(streamEventType, statementContext.StatementResultService);
// validation
var routerDesc = services.InternalEventRouter.GetValidatePreprocessing(onExprView.EventType, updateSpec, statementContext.Annotations);
// create context factory
var contextFactory = new StatementAgentInstanceFactoryUpdate(statementContext, services, streamEventType, updateSpec, onExprView, routerDesc, subSelectStrategyCollection);
// perform start of hook-up to start
Viewable finalViewable;
EPStatementStopMethod stopStatementMethod;
IDictionary <ExprSubselectNode, SubSelectStrategyHolder> subselectStrategyInstances;
// With context - delegate instantiation to context
EPStatementStopMethod stopMethod = new EPStatementStopMethodImpl(statementContext, stopCallbacks).Stop;
if (StatementSpec.OptionalContextName != null)
{
// use statement-wide agent-instance-specific subselects
var aiRegistryExpr = statementContext.StatementAgentInstanceRegistry.AgentInstanceExprService;
subselectStrategyInstances = new Dictionary <ExprSubselectNode, SubSelectStrategyHolder>();
foreach (var node in subSelectStrategyCollection.Subqueries.Keys)
{
var specificService = aiRegistryExpr.AllocateSubselect(node);
node.Strategy = specificService;
subselectStrategyInstances.Put(node, new SubSelectStrategyHolder(null, null, null, null, null, null));
}
var mergeView = new ContextMergeView(onExprView.EventType);
finalViewable = mergeView;
var statement = new ContextManagedStatementOnTriggerDesc(StatementSpec, statementContext, mergeView, contextFactory);
services.ContextManagementService.AddStatement(StatementSpec.OptionalContextName, statement, isRecoveringResilient);
stopStatementMethod = () =>
{
services.ContextManagementService.StoppedStatement(contextName, statementContext.StatementName, statementContext.StatementId);
stopMethod.Invoke();
};
destroyCallbacks.AddCallback(EPStatementDestroyCallbackContext.New(
services.ContextManagementService,
StatementSpec.OptionalContextName,
statementContext.StatementName,
statementContext.StatementId));
}
// Without context - start here
else
{
var agentInstanceContext = GetDefaultAgentInstanceContext(statementContext);
var resultOfStart = (StatementAgentInstanceFactoryUpdateResult)
contextFactory.NewContext(agentInstanceContext, isRecoveringResilient);
finalViewable = resultOfStart.FinalView;
stopStatementMethod = new EPStatementStopMethod(() =>
{
resultOfStart.StopCallback.Invoke();
stopMethod.Invoke();
});
subselectStrategyInstances = resultOfStart.SubselectStrategies;
}
// assign subquery nodes
EPStatementStartMethodHelperAssignExpr.AssignSubqueryStrategies(subSelectStrategyCollection, subselectStrategyInstances);
return(new EPStatementStartResult(finalViewable, stopStatementMethod, destroyCallbacks.Destroy));
}
public override EPStatementStartResult StartInternal(EPServicesContext services, StatementContext statementContext, bool isNewStatement, bool isRecoveringStatement, bool isRecoveringResilient)
{
// validate use of table: may not both read and write
ValidateTableAccessUse(StatementSpec.IntoTableSpec, StatementSpec.TableNodes);
var contextName = StatementSpec.OptionalContextName;
var defaultAgentInstanceContext = GetDefaultAgentInstanceContext(statementContext);
var selectDesc = EPStatementStartMethodSelectUtil.Prepare(StatementSpec, services, statementContext, isRecoveringResilient, defaultAgentInstanceContext, IsQueryPlanLogging(services), null, null, null);
statementContext.StatementAgentInstanceFactory = selectDesc.StatementAgentInstanceFactorySelect;
// allow extension to walk
statementContext.StatementExtensionServicesContext.PreStartWalk(selectDesc);
// Determine context
EPStatementStopMethod stopStatementMethod;
Viewable finalViewable;
AggregationService aggregationService;
IDictionary <ExprSubselectNode, SubSelectStrategyHolder> subselectStrategyInstances;
IDictionary <ExprPriorNode, ExprPriorEvalStrategy> priorStrategyInstances;
IDictionary <ExprPreviousNode, ExprPreviousEvalStrategy> previousStrategyInstances;
IDictionary <ExprTableAccessNode, ExprTableAccessEvalStrategy> tableAccessStrategyInstances;
var preloadList = Collections.GetEmptyList <StatementAgentInstancePreload>();
RegexExprPreviousEvalStrategy matchRecognizePrevEvalStrategy;
// With context - delegate instantiation to context
if (StatementSpec.OptionalContextName != null)
{
// use statement-wide agent-instance-specific aggregation service
aggregationService = statementContext.StatementAgentInstanceRegistry.AgentInstanceAggregationService;
// use statement-wide agent-instance-specific subselects
var aiRegistryExpr = statementContext.StatementAgentInstanceRegistry.AgentInstanceExprService;
subselectStrategyInstances = new Dictionary <ExprSubselectNode, SubSelectStrategyHolder>();
foreach (var entry in selectDesc.SubSelectStrategyCollection.Subqueries)
{
var specificService = aiRegistryExpr.AllocateSubselect(entry.Key);
entry.Key.Strategy = specificService;
IDictionary <ExprPriorNode, ExprPriorEvalStrategy> subselectPriorStrategies = new Dictionary <ExprPriorNode, ExprPriorEvalStrategy>();
foreach (var subselectPrior in entry.Value.PriorNodesList)
{
var specificSubselectPriorService = aiRegistryExpr.AllocatePrior(subselectPrior);
subselectPriorStrategies.Put(subselectPrior, specificSubselectPriorService);
}
IDictionary <ExprPreviousNode, ExprPreviousEvalStrategy> subselectPreviousStrategies = new Dictionary <ExprPreviousNode, ExprPreviousEvalStrategy>();
foreach (var subselectPrevious in entry.Value.PrevNodesList)
{
var specificSubselectPreviousService = aiRegistryExpr.AllocatePrevious(subselectPrevious);
subselectPreviousStrategies.Put(subselectPrevious, specificSubselectPreviousService);
}
var subselectAggregation = aiRegistryExpr.AllocateSubselectAggregation(entry.Key);
var strategyHolder = new SubSelectStrategyHolder(specificService, subselectAggregation, subselectPriorStrategies, subselectPreviousStrategies, null, null);
subselectStrategyInstances.Put(entry.Key, strategyHolder);
}
// use statement-wide agent-instance-specific "prior"
priorStrategyInstances = new Dictionary <ExprPriorNode, ExprPriorEvalStrategy>();
foreach (var priorNode in selectDesc.ViewResourceDelegateUnverified.PriorRequests)
{
var specificService = aiRegistryExpr.AllocatePrior(priorNode);
priorStrategyInstances.Put(priorNode, specificService);
}
// use statement-wide agent-instance-specific "previous"
previousStrategyInstances = new Dictionary <ExprPreviousNode, ExprPreviousEvalStrategy>();
foreach (var previousNode in selectDesc.ViewResourceDelegateUnverified.PreviousRequests)
{
var specificService = aiRegistryExpr.AllocatePrevious(previousNode);
previousStrategyInstances.Put(previousNode, specificService);
}
// use statement-wide agent-instance-specific match-recognize "previous"
matchRecognizePrevEvalStrategy = aiRegistryExpr.AllocateMatchRecognizePrevious();
// use statement-wide agent-instance-specific tables
tableAccessStrategyInstances = new Dictionary <ExprTableAccessNode, ExprTableAccessEvalStrategy>();
if (StatementSpec.TableNodes != null)
{
foreach (ExprTableAccessNode tableNode in StatementSpec.TableNodes)
{
var specificService = aiRegistryExpr.AllocateTableAccess(tableNode);
tableAccessStrategyInstances.Put(tableNode, specificService);
}
}
var mergeView = new ContextMergeView(selectDesc.ResultSetProcessorPrototypeDesc.ResultSetProcessorFactory.ResultEventType);
finalViewable = mergeView;
var statement = new ContextManagedStatementSelectDesc(StatementSpec, statementContext, mergeView, selectDesc.StatementAgentInstanceFactorySelect,
selectDesc.ResultSetProcessorPrototypeDesc.AggregationServiceFactoryDesc.Expressions,
selectDesc.SubSelectStrategyCollection);
services.ContextManagementService.AddStatement(contextName, statement, isRecoveringResilient);
var selectStop = selectDesc.StopMethod;
stopStatementMethod = () =>
{
services.ContextManagementService.StoppedStatement(contextName, statementContext.StatementName, statementContext.StatementId);
selectStop.Invoke();
};
selectDesc.DestroyCallbacks.AddCallback(EPStatementDestroyCallbackContext.New(services.ContextManagementService, contextName, statementContext.StatementName, statementContext.StatementId));
}
// Without context - start here
else
{
var resultOfStart = (StatementAgentInstanceFactorySelectResult)selectDesc.StatementAgentInstanceFactorySelect.NewContext(defaultAgentInstanceContext, isRecoveringResilient);
finalViewable = resultOfStart.FinalView;
var selectStop = selectDesc.StopMethod;
var startResultStop = resultOfStart.StopCallback;
stopStatementMethod = () =>
{
StatementAgentInstanceUtil.StopSafe(startResultStop, statementContext);
selectStop.Invoke();
};
aggregationService = resultOfStart.OptionalAggegationService;
subselectStrategyInstances = resultOfStart.SubselectStrategies;
priorStrategyInstances = resultOfStart.PriorNodeStrategies;
previousStrategyInstances = resultOfStart.PreviousNodeStrategies;
tableAccessStrategyInstances = resultOfStart.TableAccessEvalStrategies;
preloadList = resultOfStart.PreloadList;
matchRecognizePrevEvalStrategy = null;
if (resultOfStart.TopViews.Length > 0)
{
EventRowRegexNFAViewService matchRecognize = EventRowRegexHelper.RecursiveFindRegexService(resultOfStart.TopViews[0]);
if (matchRecognize != null)
{
matchRecognizePrevEvalStrategy = matchRecognize.PreviousEvaluationStrategy;
}
}
if (statementContext.StatementExtensionServicesContext != null && statementContext.StatementExtensionServicesContext.StmtResources != null)
{
StatementResourceHolder holder = statementContext.StatementExtensionServicesContext.ExtractStatementResourceHolder(resultOfStart);
statementContext.StatementExtensionServicesContext.StmtResources.Unpartitioned = holder;
statementContext.StatementExtensionServicesContext.PostProcessStart(resultOfStart, isRecoveringResilient);
}
}
var matchRecognizeNodes = selectDesc.StatementAgentInstanceFactorySelect.ViewResourceDelegate.PerStream[0].MatchRecognizePreviousRequests;
// assign strategies to expression nodes
EPStatementStartMethodHelperAssignExpr.AssignExpressionStrategies(
selectDesc, aggregationService, subselectStrategyInstances, priorStrategyInstances,
previousStrategyInstances, matchRecognizeNodes, matchRecognizePrevEvalStrategy,
tableAccessStrategyInstances);
// execute preload if any
foreach (var preload in preloadList)
{
preload.ExecutePreload();
}
// handle association to table
if (StatementSpec.IntoTableSpec != null)
{
services.StatementVariableRefService.AddReferences(statementContext.StatementName, StatementSpec.IntoTableSpec.Name);
}
return(new EPStatementStartResult(finalViewable, stopStatementMethod, selectDesc.DestroyCallbacks.Destroy));
}
