public override EPStatementStartResult StartInternal(
EPServicesContext services,
StatementContext statementContext,
bool isNewStatement,
bool isRecoveringStatement,
bool isRecoveringResilient)
{
var expressionName =
services.ExprDeclaredService.AddExpressionOrScript(StatementSpec.CreateExpressionDesc);
// define output event type
var typeName = "EventType_Expression_" + expressionName;
var resultType = services.EventAdapterService.CreateAnonymousMapType(
typeName, Collections.GetEmptyMap <String, Object>(), true);
var stopMethod = new ProxyEPStatementStopMethod(
() =>
{
// no action
});
var destroyMethod = new ProxyEPStatementDestroyMethod(
() => services.ExprDeclaredService.DestroyedExpression(StatementSpec.CreateExpressionDesc));
Viewable resultView = new ZeroDepthStreamNoIterate(resultType);
statementContext.StatementAgentInstanceFactory = new StatementAgentInstanceFactoryNoAgentInstance(resultView);
return(new EPStatementStartResult(resultView, stopMethod, destroyMethod));
}
public override EPStatementStartResult StartInternal(EPServicesContext services, StatementContext statementContext, bool isNewStatement, bool isRecoveringStatement, bool isRecoveringResilient)
{
var createGraphDesc = StatementSpec.CreateGraphDesc;
var agentInstanceContext = GetDefaultAgentInstanceContext(statementContext);
// define output event type
var typeName = "EventType_Graph_" + createGraphDesc.GraphName;
var resultType = services.EventAdapterService.CreateAnonymousMapType(typeName, Collections.GetEmptyMap <String, Object>(), true);
services.DataFlowService.AddStartGraph(createGraphDesc, statementContext, services, agentInstanceContext, isNewStatement);
var stopMethod = new ProxyEPStatementStopMethod(() =>
services.DataFlowService.StopGraph(createGraphDesc.GraphName));
var destroyMethod = new ProxyEPStatementDestroyMethod(() =>
services.DataFlowService.RemoveGraph(createGraphDesc.GraphName));
var resultView = new ZeroDepthStreamNoIterate(resultType);
statementContext.StatementAgentInstanceFactory = new StatementAgentInstanceFactoryNoAgentInstance(resultView);
return(new EPStatementStartResult(resultView, stopMethod, destroyMethod));
}
public override EPStatementStartResult StartInternal(
EPServicesContext services,
StatementContext statementContext,
bool isNewStatement,
bool isRecoveringStatement,
bool isRecoveringResilient)
{
CreateSchemaDesc spec = StatementSpec.CreateSchemaDesc;
EPLValidationUtil.ValidateTableExists(services.TableService, spec.SchemaName);
EventType eventType = HandleCreateSchema(services, statementContext, spec);
// enter a reference
services.StatementEventTypeRefService.AddReferences(
statementContext.StatementName, new String[]
{
spec.SchemaName
});
EventType allocatedEventType = eventType;
EPStatementStopMethod stopMethod = new ProxyEPStatementStopMethod(() =>
{
services.StatementEventTypeRefService.RemoveReferencesStatement(statementContext.StatementName);
if (services.StatementEventTypeRefService.GetStatementNamesForType(spec.SchemaName).IsEmpty())
{
services.EventAdapterService.RemoveType(allocatedEventType.Name);
services.FilterService.RemoveType(allocatedEventType);
}
});
Viewable viewable = new ViewableDefaultImpl(eventType);
// assign agent instance factory (an empty op)
statementContext.StatementAgentInstanceFactory = new StatementAgentInstanceFactoryNoAgentInstance(viewable);
return(new EPStatementStartResult(viewable, stopMethod, null));
}
public override EPStatementStartResult StartInternal(
EPServicesContext services,
StatementContext statementContext,
bool isNewStatement,
bool isRecoveringStatement,
bool isRecoveringResilient)
{
if (_statementSpec.OptionalContextName != null)
{
throw new ExprValidationException("A create-context statement cannot itself be associated to a context, please declare a nested context instead");
}
var context = _statementSpec.ContextDesc;
var agentInstanceContext = GetDefaultAgentInstanceContext(statementContext);
// compile filter specs, if any
ISet <string> eventTypesReferenced = new HashSet <string>();
ValidateContextDetail(services, statementContext, eventTypesReferenced, context.ContextDetail, agentInstanceContext);
services.StatementEventTypeRefService.AddReferences(statementContext.StatementName, CollectionUtil.ToArray(eventTypesReferenced));
// define output event type
var typeName = "EventType_Context_" + context.ContextName;
var statementResultEventType = services.EventAdapterService.CreateAnonymousMapType(typeName, Collections.GetEmptyMap <string, object>(), true);
// add context - does not activate that context
services.ContextManagementService.AddContextSpec(services, agentInstanceContext, context, isRecoveringResilient, statementResultEventType);
EPStatementStopMethod stopMethod = new ProxyEPStatementStopMethod(() =>
{
// no action
});
EPStatementDestroyMethod destroyMethod = new ProxyEPStatementDestroyMethod(() => services.ContextManagementService.DestroyedContext(context.ContextName));
return(new EPStatementStartResult(new ZeroDepthStreamNoIterate(statementResultEventType), stopMethod, destroyMethod));
}
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, 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 = new ProxyEPStatementStopMethod(() =>
{
services.ContextManagementService.StoppedStatement(
contextName,
statementContext.StatementName,
statementContext.StatementId,
statementContext.Expression,
statementContext.ExceptionHandlingService);
selectStop.Stop();
});
selectDesc.DestroyCallbacks.AddCallback(new EPStatementDestroyCallbackContext(services.ContextManagementService, contextName, statementContext.StatementName, statementContext.StatementId));
}
// Without context - start here
else
{
var resultOfStart = (StatementAgentInstanceFactorySelectResult)selectDesc.StatementAgentInstanceFactorySelect.NewContext(defaultAgentInstanceContext, isRecoveringResilient);
finalViewable = resultOfStart.FinalView;
var startResultStop = services.EpStatementFactory.MakeStopMethod(resultOfStart);
var selectStop = selectDesc.StopMethod;
stopStatementMethod = new ProxyEPStatementStopMethod(() =>
{
StatementAgentInstanceUtil.StopSafe(startResultStop, statementContext);
selectStop.Stop();
});
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));
}
public override EPStatementStartResult StartInternal(
EPServicesContext services,
StatementContext statementContext,
bool isNewStatement,
bool isRecoveringStatement,
bool isRecoveringResilient)
{
var createDesc = _statementSpec.CreateVariableDesc;
VariableServiceUtil.CheckAlreadyDeclaredTable(createDesc.VariableName, services.TableService);
// Get assignment value
object value = null;
if (createDesc.Assignment != null)
{
// Evaluate assignment expression
StreamTypeService typeService = new StreamTypeServiceImpl(
new EventType[0], new string[0], new bool[0], services.EngineURI, false);
var evaluatorContextStmt = new ExprEvaluatorContextStatement(statementContext, false);
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);
var validated = ExprNodeUtility.GetValidatedSubtree(
ExprNodeOrigin.VARIABLEASSIGN, createDesc.Assignment, validationContext);
value = validated.ExprEvaluator.Evaluate(new EvaluateParams(null, true, evaluatorContextStmt));
}
// Create variable
try
{
services.VariableService.CreateNewVariable(
_statementSpec.OptionalContextName, createDesc.VariableName, createDesc.VariableType, createDesc.IsConstant,
createDesc.IsArray, createDesc.IsArrayOfPrimitive, value, services.EngineImportService);
}
catch (VariableExistsException ex)
{
// for new statement we don't allow creating the same variable
if (isNewStatement)
{
throw new ExprValidationException("Cannot create variable: " + ex.Message, ex);
}
}
catch (VariableDeclarationException ex)
{
throw new ExprValidationException("Cannot create variable: " + ex.Message, ex);
}
var destroyMethod = new EPStatementDestroyCallbackList();
destroyMethod.AddCallback(new ProxyDestroyCallback(() =>
{
try
{
services.StatementVariableRefService.RemoveReferencesStatement(statementContext.StatementName);
}
catch (Exception ex)
{
Log.Error("Error removing variable '" + createDesc.VariableName + "': " + ex.Message);
}
}));
var stopMethod = new ProxyEPStatementStopMethod(() => { });
var variableMetaData = services.VariableService.GetVariableMetaData(createDesc.VariableName);
Viewable outputView;
var eventType = CreateVariableView.GetEventType(
statementContext.StatementId, services.EventAdapterService, variableMetaData);
var contextFactory =
new StatementAgentInstanceFactoryCreateVariable(
createDesc, _statementSpec, statementContext, services, variableMetaData, eventType);
statementContext.StatementAgentInstanceFactory = contextFactory;
if (_statementSpec.OptionalContextName != null)
{
var mergeView = new ContextMergeView(eventType);
outputView = mergeView;
var statement =
new ContextManagedStatementCreateVariableDesc(_statementSpec, statementContext, mergeView, contextFactory);
services.ContextManagementService.AddStatement(
_statementSpec.OptionalContextName, statement, isRecoveringResilient);
var contextManagementService = services.ContextManagementService;
destroyMethod.AddCallback(new ProxyDestroyCallback(() => contextManagementService.DestroyedStatement(
_statementSpec.OptionalContextName, statementContext.StatementName,
statementContext.StatementId)));
}
else
{
var resultOfStart =
(StatementAgentInstanceFactoryCreateVariableResult)
contextFactory.NewContext(GetDefaultAgentInstanceContext(statementContext), isRecoveringResilient);
outputView = resultOfStart.FinalView;
if (statementContext.StatementExtensionServicesContext != null &&
statementContext.StatementExtensionServicesContext.StmtResources != null)
{
var holder =
statementContext.StatementExtensionServicesContext.ExtractStatementResourceHolder(resultOfStart);
statementContext.StatementExtensionServicesContext.StmtResources.Unpartitioned = holder;
statementContext.StatementExtensionServicesContext.PostProcessStart(resultOfStart, isRecoveringResilient);
}
}
services.StatementVariableRefService.AddReferences(
statementContext.StatementName, Collections.SingletonList(createDesc.VariableName), null);
return(new EPStatementStartResult(outputView, stopMethod, destroyMethod));
}
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));
}
public override EPStatementStartResult StartInternal(EPServicesContext services, StatementContext statementContext, bool isNewStatement, bool isRecoveringStatement, bool isRecoveringResilient)
{
var spec = _statementSpec.CreateIndexDesc;
var namedWindowProcessor = services.NamedWindowMgmtService.GetProcessor(spec.WindowName);
var tableMetadata = services.TableService.GetTableMetadata(spec.WindowName);
if (namedWindowProcessor == null && tableMetadata == null)
{
throw new ExprValidationException("A named window or table by name '" + spec.WindowName + "' does not exist");
}
var indexedEventType = namedWindowProcessor != null ? namedWindowProcessor.NamedWindowType : tableMetadata.InternalEventType;
var infraContextName = namedWindowProcessor != null ? namedWindowProcessor.ContextName : tableMetadata.ContextName;
EPLValidationUtil.ValidateContextName(namedWindowProcessor == null, spec.WindowName, infraContextName, _statementSpec.OptionalContextName, true);
// validate index
var explicitIndexDesc = EventTableIndexUtil.ValidateCompileExplicitIndex(spec.IndexName, spec.IsUnique, spec.Columns, indexedEventType, statementContext);
var advancedIndexDesc = explicitIndexDesc.AdvancedIndexProvisionDesc == null ? null : explicitIndexDesc.AdvancedIndexProvisionDesc.IndexDesc;
var imk = new IndexMultiKey(spec.IsUnique, explicitIndexDesc.HashPropsAsList, explicitIndexDesc.BtreePropsAsList, advancedIndexDesc);
// for tables we add the index to metadata
if (tableMetadata != null)
{
services.TableService.ValidateAddIndex(statementContext.StatementName, tableMetadata, spec.IndexName, explicitIndexDesc, imk);
}
else
{
namedWindowProcessor.ValidateAddIndex(statementContext.StatementName, spec.IndexName, explicitIndexDesc, imk);
}
// allocate context factory
Viewable viewable = new ViewableDefaultImpl(indexedEventType);
var contextFactory = new StatementAgentInstanceFactoryCreateIndex(
services, spec, viewable, namedWindowProcessor,
tableMetadata?.TableName,
_statementSpec.OptionalContextName,
explicitIndexDesc);
statementContext.StatementAgentInstanceFactory = contextFactory;
// provide destroy method which de-registers interest in this index
var finalTableService = services.TableService;
var finalStatementName = statementContext.StatementName;
var destroyMethod = new EPStatementDestroyCallbackList();
if (tableMetadata != null)
{
destroyMethod.AddCallback(() => finalTableService.RemoveIndexReferencesStmtMayRemoveIndex(finalStatementName, tableMetadata));
}
else
{
destroyMethod.AddCallback(() => namedWindowProcessor.RemoveIndexReferencesStmtMayRemoveIndex(imk, finalStatementName));
}
EPStatementStopMethod stopMethod;
if (_statementSpec.OptionalContextName != null)
{
var mergeView = new ContextMergeView(indexedEventType);
var statement = new ContextManagedStatementCreateIndexDesc(_statementSpec, statementContext, mergeView, contextFactory);
services.ContextManagementService.AddStatement(_statementSpec.OptionalContextName, statement, isRecoveringResilient);
stopMethod = new ProxyEPStatementStopMethod(() => {});
var contextManagementService = services.ContextManagementService;
destroyMethod.AddCallback(() => contextManagementService.DestroyedStatement(_statementSpec.OptionalContextName, statementContext.StatementName, statementContext.StatementId));
}
else
{
var defaultAgentInstanceContext = GetDefaultAgentInstanceContext(statementContext);
StatementAgentInstanceFactoryResult result;
try {
result = contextFactory.NewContext(defaultAgentInstanceContext, isRecoveringResilient);
}
catch (EPException ex) {
if (ex.InnerException is ExprValidationException)
{
throw (ExprValidationException)ex.InnerException;
}
destroyMethod.Destroy();
throw;
}
catch (Exception)
{
destroyMethod.Destroy();
throw;
}
var stopCallback = services.EpStatementFactory.MakeStopMethod(result);
stopMethod = new ProxyEPStatementStopMethod(stopCallback.Stop);
if (statementContext.StatementExtensionServicesContext != null && statementContext.StatementExtensionServicesContext.StmtResources != null)
{
var holder = statementContext.StatementExtensionServicesContext.ExtractStatementResourceHolder(result);
statementContext.StatementExtensionServicesContext.StmtResources.Unpartitioned = holder;
statementContext.StatementExtensionServicesContext.PostProcessStart(result, isRecoveringResilient);
}
}
if (tableMetadata != null)
{
services.StatementVariableRefService.AddReferences(statementContext.StatementName, tableMetadata.TableName);
}
else
{
services.StatementVariableRefService.AddReferences(statementContext.StatementName, namedWindowProcessor.NamedWindowType.Name);
}
return(new EPStatementStartResult(viewable, stopMethod, destroyMethod));
}
public override EPStatementStartResult StartInternal(
EPServicesContext services,
StatementContext statementContext,
bool isNewStatement,
bool isRecoveringStatement,
bool isRecoveringResilient)
{
var statementSpec = base.StatementSpec;
// 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);
var 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(
statementContext.Container,
typeService,
statementContext.EngineImportService,
statementContext.StatementExtensionServicesContext,
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);
statementContext.StatementAgentInstanceFactory = contextFactory;
// perform start of hook-up to start
Viewable finalViewable;
EPStatementStopMethod stopStatementMethod;
IDictionary <ExprSubselectNode, SubSelectStrategyHolder> subselectStrategyInstances;
// With context - delegate instantiation to context
var stopMethod = new EPStatementStopMethodImpl(statementContext, stopCallbacks);
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, 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 = new ProxyEPStatementStopMethod
{
ProcStop = () =>
{
services.ContextManagementService.StoppedStatement(
contextName, statementContext.StatementName, statementContext.StatementId,
statementContext.Expression, statementContext.ExceptionHandlingService);
stopMethod.Stop();
}
};
destroyCallbacks.AddCallback(
new EPStatementDestroyCallbackContext(
services.ContextManagementService, statementSpec.OptionalContextName,
statementContext.StatementName, statementContext.StatementId));
}
else
{
// Without context - start here
var agentInstanceContext = GetDefaultAgentInstanceContext(statementContext);
var resultOfStart =
(StatementAgentInstanceFactoryUpdateResult)
contextFactory.NewContext(agentInstanceContext, isRecoveringResilient);
finalViewable = resultOfStart.FinalView;
var stopCallback = services.EpStatementFactory.MakeStopMethod(resultOfStart);
stopStatementMethod = new ProxyEPStatementStopMethod
{
ProcStop = () =>
{
stopCallback.Stop();
stopMethod.Stop();
}
};
subselectStrategyInstances = resultOfStart.SubselectStrategies;
if (statementContext.StatementExtensionServicesContext != null &&
statementContext.StatementExtensionServicesContext.StmtResources != null)
{
var holder =
statementContext.StatementExtensionServicesContext.ExtractStatementResourceHolder(resultOfStart);
statementContext.StatementExtensionServicesContext.StmtResources.Unpartitioned = holder;
statementContext.StatementExtensionServicesContext.PostProcessStart(
resultOfStart, isRecoveringResilient);
}
}
// assign subquery nodes
EPStatementStartMethodHelperAssignExpr.AssignSubqueryStrategies(
subSelectStrategyCollection, subselectStrategyInstances);
return(new EPStatementStartResult(finalViewable, stopStatementMethod, destroyCallbacks));
}
public override EPStatementStartResult StartInternal(EPServicesContext services, StatementContext statementContext, bool isNewStatement, bool isRecoveringStatement, bool isRecoveringResilient)
{
var createDesc = _statementSpec.CreateTableDesc;
// determine whether already declared
VariableServiceUtil.CheckAlreadyDeclaredVariable(createDesc.TableName, services.VariableService);
if (isNewStatement)
{
VariableServiceUtil.CheckAlreadyDeclaredTable(createDesc.TableName, services.TableService);
}
if (services.EventAdapterService.GetEventTypeByName(createDesc.TableName) != null)
{
throw new ExprValidationException("An event type or schema by name '" + createDesc.TableName + "' already exists");
}
// Determine event type names
var internalTypeName = "table_" + createDesc.TableName + "__internal";
var publicTypeName = "table_" + createDesc.TableName + "__public";
TableMetadata metadata;
try
{
// determine key types
var keyTypes = GetKeyTypes(createDesc.Columns, services.EngineImportService);
// check column naming, interpret annotations
var columnDescs = ValidateExpressions(createDesc.Columns, services, statementContext);
// analyze and plan the state holders
var plan = AnalyzePlanAggregations(createDesc.TableName, statementContext, columnDescs, services, internalTypeName, publicTypeName);
var tableStateRowFactory = plan.StateRowFactory;
// register new table
var queryPlanLogging = services.ConfigSnapshot.EngineDefaults.Logging.IsEnableQueryPlan;
metadata = services.TableService.AddTable(createDesc.TableName, statementContext.Expression, statementContext.StatementName, keyTypes, plan.TableColumns, tableStateRowFactory, plan.NumberMethodAggregations, statementContext, plan.InternalEventType,
plan.PublicEventType, plan.EventToPublic, queryPlanLogging);
}
catch (ExprValidationException ex)
{
services.EventAdapterService.RemoveType(internalTypeName);
services.EventAdapterService.RemoveType(publicTypeName);
throw ex;
}
// allocate context factory
var contextFactory = new StatementAgentInstanceFactoryCreateTable(metadata);
statementContext.StatementAgentInstanceFactory = contextFactory;
Viewable outputView;
EPStatementStopMethod stopStatementMethod;
EPStatementDestroyMethod destroyStatementMethod;
if (_statementSpec.OptionalContextName != null)
{
var contextName = _statementSpec.OptionalContextName;
var mergeView = new ContextMergeView(metadata.PublicEventType);
outputView = mergeView;
var statement = new ContextManagedStatementCreateAggregationVariableDesc(_statementSpec, statementContext, mergeView, contextFactory);
services.ContextManagementService.AddStatement(_statementSpec.OptionalContextName, statement, isRecoveringResilient);
stopStatementMethod = new ProxyEPStatementStopMethod(() =>
services.ContextManagementService.StoppedStatement(
contextName, statementContext.StatementName, statementContext.StatementId,
statementContext.Expression, statementContext.ExceptionHandlingService));
destroyStatementMethod = new ProxyEPStatementDestroyMethod(() =>
{
services.ContextManagementService.DestroyedStatement(contextName, statementContext.StatementName, statementContext.StatementId);
services.StatementVariableRefService.RemoveReferencesStatement(statementContext.StatementName);
});
}
else
{
var defaultAgentInstanceContext = GetDefaultAgentInstanceContext(statementContext);
var result = contextFactory.NewContext(defaultAgentInstanceContext, false);
if (statementContext.StatementExtensionServicesContext != null && statementContext.StatementExtensionServicesContext.StmtResources != null)
{
var holder = statementContext.StatementExtensionServicesContext.ExtractStatementResourceHolder(result);
statementContext.StatementExtensionServicesContext.StmtResources.Unpartitioned = holder;
}
outputView = result.FinalView;
stopStatementMethod = new ProxyEPStatementStopMethod(() => { });
destroyStatementMethod = new ProxyEPStatementDestroyMethod(() =>
services.StatementVariableRefService.RemoveReferencesStatement(statementContext.StatementName));
}
services.StatementVariableRefService.AddReferences(statementContext.StatementName, createDesc.TableName);
return(new EPStatementStartResult(outputView, stopStatementMethod, destroyStatementMethod));
}
