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);
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>());
// add context - does not activate that context
services.ContextManagementService.AddContextSpec(services, agentInstanceContext, context, isRecoveringResilient, statementResultEventType);
var stopMethod = new EPStatementStopMethod(() => { });
var destroyMethod = new EPStatementDestroyMethod(
() => services.ContextManagementService.DestroyedContext(context.ContextName));
return(new EPStatementStartResult(new ZeroDepthStreamNoIterate(statementResultEventType), stopMethod, destroyMethod));
}
/// <summary>Ctor. </summary>
/// <param name="viewable">last view to attach listeners to</param>
/// <param name="stopMethod">method to stop</param>
public EPStatementStartResult(Viewable viewable,
EPStatementStopMethod stopMethod)
{
Viewable = viewable;
StopMethod = stopMethod;
DestroyMethod = null;
}
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 = () =>
{
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);
return(new EPStatementStartResult(viewable, stopMethod, null));
}
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>());
var stopMethod = new EPStatementStopMethod(
() =>
{
// no action
});
var destroyMethod = new EPStatementDestroyMethod(
() => services.ExprDeclaredService.DestroyedExpression(StatementSpec.CreateExpressionDesc));
return(new EPStatementStartResult(new ZeroDepthStreamNoIterate(resultType), stopMethod, destroyMethod));
}
public EPStatementStartMethodSelectDesc(
StatementAgentInstanceFactorySelect statementAgentInstanceFactorySelect,
SubSelectStrategyCollection subSelectStrategyCollection,
ViewResourceDelegateUnverified viewResourceDelegateUnverified,
ResultSetProcessorFactoryDesc resultSetProcessorPrototypeDesc,
EPStatementStopMethod stopMethod,
EPStatementDestroyCallbackList destroyCallbacks)
{
StatementAgentInstanceFactorySelect = statementAgentInstanceFactorySelect;
SubSelectStrategyCollection = subSelectStrategyCollection;
ViewResourceDelegateUnverified = viewResourceDelegateUnverified;
ResultSetProcessorPrototypeDesc = resultSetProcessorPrototypeDesc;
StopMethod = stopMethod;
DestroyCallbacks = destroyCallbacks;
}
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>());
services.DataFlowService.AddStartGraph(createGraphDesc, statementContext, services, agentInstanceContext, isNewStatement);
var stopMethod = new EPStatementStopMethod(() =>
services.DataFlowService.StopGraph(createGraphDesc.GraphName));
var destroyMethod = new EPStatementDestroyMethod(() =>
services.DataFlowService.RemoveGraph(createGraphDesc.GraphName));
return(new EPStatementStartResult(new ZeroDepthStreamNoIterate(resultType), stopMethod, destroyMethod));
}
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)
{
var createDesc = StatementSpec.CreateVariableDesc;
VariableServiceUtil.CheckAlreadyDeclaredTable(createDesc.VariableName, services.TableService);
// Get assignment value
Object value = null;
if (createDesc.Assignment != null)
{
// Evaluate assignment expression
var 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(
() =>
{
try
{
services.StatementVariableRefService.RemoveReferencesStatement(statementContext.StatementName);
}
catch (Exception ex)
{
Log.Error("Error removing variable '" + createDesc.VariableName + "': " + ex.Message);
}
});
var stopMethod = new EPStatementStopMethod(() => { });
VariableMetaData variableMetaData = services.VariableService.GetVariableMetaData(createDesc.VariableName);
Viewable outputView;
if (StatementSpec.OptionalContextName != null)
{
EventType eventType = CreateVariableView.GetEventType(statementContext.StatementId, services.EventAdapterService, variableMetaData);
var contextFactory = new StatementAgentInstanceFactoryCreateVariable(statementContext, services, variableMetaData, eventType);
var mergeView = new ContextMergeView(eventType);
outputView = mergeView;
var statement = new ContextManagedStatementCreateVariableDesc(StatementSpec, statementContext, mergeView, contextFactory);
services.ContextManagementService.AddStatement(StatementSpec.OptionalContextName, statement, isRecoveringResilient);
ContextManagementService contextManagementService = services.ContextManagementService;
destroyMethod.AddCallback(() => contextManagementService.DestroyedStatement(StatementSpec.OptionalContextName, statementContext.StatementName, statementContext.StatementId));
}
else
{
// allocate
services.VariableService.AllocateVariableState(createDesc.VariableName, VariableServiceConstants.NOCONTEXT_AGENTINSTANCEID, statementContext.StatementExtensionServicesContext);
var createView = new CreateVariableView(statementContext.StatementId, services.EventAdapterService, services.VariableService, createDesc.VariableName, statementContext.StatementResultService);
services.VariableService.RegisterCallback(createDesc.VariableName, 0, createView.Update);
statementContext.StatementStopService.StatementStopped +=
() => services.VariableService.UnregisterCallback(createDesc.VariableName, 0, createView.Update);
// Create result set processor, use wildcard selection
StatementSpec.SelectClauseSpec.SetSelectExprList(new SelectClauseElementWildcard());
StatementSpec.SelectStreamDirEnum = SelectClauseStreamSelectorEnum.RSTREAM_ISTREAM_BOTH;
StreamTypeService typeService = new StreamTypeServiceImpl(new EventType[] { createView.EventType }, new String[] { "create_variable" }, new bool[] { true }, services.EngineURI, false);
var agentInstanceContext = GetDefaultAgentInstanceContext(statementContext);
var resultSetProcessorPrototype = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
StatementSpec, statementContext, typeService, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, services.ConfigSnapshot);
var resultSetProcessor = EPStatementStartMethodHelperAssignExpr.GetAssignResultSetProcessor(agentInstanceContext, resultSetProcessorPrototype);
// Attach output view
var outputViewFactory = OutputProcessViewFactoryFactory.Make(StatementSpec, services.InternalEventRouter, agentInstanceContext.StatementContext, resultSetProcessor.ResultEventType, null, services.TableService, resultSetProcessorPrototype.ResultSetProcessorFactory.ResultSetProcessorType);
var outputViewBase = outputViewFactory.MakeView(resultSetProcessor, agentInstanceContext);
createView.AddView(outputViewBase);
outputView = outputViewBase;
}
services.StatementVariableRefService.AddReferences(statementContext.StatementName, Collections.SingletonList(createDesc.VariableName), null);
return(new EPStatementStartResult(outputView, stopMethod, destroyMethod.Destroy));
}
public override EPStatementStartResult StartInternal(EPServicesContext services, StatementContext statementContext, bool isNewStatement, bool isRecoveringStatement, bool isRecoveringResilient)
{
CreateTableDesc 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");
}
EPStatementDestroyMethod destroyMethod = new EPStatementDestroyMethod(() =>
{
try
{
services.StatementVariableRefService.RemoveReferencesStatement(statementContext.StatementName);
}
catch (Exception ex) {
log.Error("Error removing table '" + createDesc.TableName + "': " + ex.Message);
}
});
EPStatementStopMethod stopMethod = new EPStatementStopMethod(() => {});
// 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.LoggingConfig.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) {
services.EventAdapterService.RemoveType(internalTypeName);
services.EventAdapterService.RemoveType(publicTypeName);
throw;
}
// allocate context factory
var contextFactory = new StatementAgentInstanceFactoryCreateTable(metadata);
Viewable outputView;
if (StatementSpec.OptionalContextName != null)
{
var mergeView = new ContextMergeView(metadata.PublicEventType);
outputView = mergeView;
var statement = new ContextManagedStatementCreateAggregationVariableDesc(StatementSpec, statementContext, mergeView, contextFactory);
services.ContextManagementService.AddStatement(StatementSpec.OptionalContextName, statement, isRecoveringResilient);
}
else
{
var defaultAgentInstanceContext = GetDefaultAgentInstanceContext(statementContext);
var result = contextFactory.NewContext(defaultAgentInstanceContext, false);
if (statementContext.StatementExtensionServicesContext != null && statementContext.StatementExtensionServicesContext.StmtResources != null)
{
StatementResourceHolder holder = statementContext.StatementExtensionServicesContext.ExtractStatementResourceHolder(result);
statementContext.StatementExtensionServicesContext.StmtResources.Unpartitioned = holder;
}
outputView = result.FinalView;
}
services.StatementVariableRefService.AddReferences(statementContext.StatementName, createDesc.TableName);
return(new EPStatementStartResult(outputView, stopMethod, destroyMethod));
}