public static OnTriggerPlanValidationResult ValidateOnTriggerPlan(
EventType namedWindowOrTableType,
OnTriggerWindowDesc onTriggerDesc,
StreamSpecCompiled streamSpec,
OnTriggerActivatorDesc activatorResult,
IDictionary<ExprSubselectNode, SubSelectActivationPlan> subselectActivation,
StatementBaseInfo @base,
StatementCompileTimeServices services)
{
var zeroStreamAliasName = onTriggerDesc.OptionalAsName;
if (zeroStreamAliasName == null) {
zeroStreamAliasName = "stream_0";
}
var streamName = streamSpec.OptionalStreamName;
if (streamName == null) {
streamName = "stream_1";
}
var namedWindowTypeName = onTriggerDesc.WindowName;
// Materialize sub-select views
// 0 - named window stream
// 1 - arriving stream
// 2 - initial value before update
string[] subselectStreamNames = {zeroStreamAliasName, streamSpec.OptionalStreamName};
EventType[] subselectEventTypes = {namedWindowOrTableType, activatorResult.ActivatorResultEventType};
string[] subselectEventTypeNames = {namedWindowTypeName, activatorResult.TriggerEventTypeName};
var subselectForges = SubSelectHelperForgePlanner.PlanSubSelect(
@base,
subselectActivation,
subselectStreamNames,
subselectEventTypes,
subselectEventTypeNames,
services);
var typeService = new StreamTypeServiceImpl(
new[] {namedWindowOrTableType, activatorResult.ActivatorResultEventType},
new[] {zeroStreamAliasName, streamName},
new[] {false, true},
true,
false);
// allow "initial" as a prefix to properties
StreamTypeServiceImpl assignmentTypeService;
if (zeroStreamAliasName.Equals(INITIAL_VALUE_STREAM_NAME) || streamName.Equals(INITIAL_VALUE_STREAM_NAME)) {
assignmentTypeService = typeService;
}
else {
assignmentTypeService = new StreamTypeServiceImpl(
new[] {namedWindowOrTableType, activatorResult.ActivatorResultEventType, namedWindowOrTableType},
new[] {zeroStreamAliasName, streamName, INITIAL_VALUE_STREAM_NAME},
new[] {false, true, true},
false,
false);
assignmentTypeService.IsStreamZeroUnambigous = true;
}
if (onTriggerDesc is OnTriggerWindowUpdateDesc) {
var updateDesc = (OnTriggerWindowUpdateDesc) onTriggerDesc;
var validationContext = new ExprValidationContextBuilder(
assignmentTypeService,
@base.StatementRawInfo,
services)
.WithAllowBindingConsumption(true)
.Build();
foreach (var assignment in updateDesc.Assignments) {
var validated = ExprNodeUtilityValidate.GetValidatedAssignment(assignment, validationContext);
assignment.Expression = validated;
EPStatementStartMethodHelperValidate.ValidateNoAggregations(
validated,
"Aggregation functions may not be used within an on-update-clause");
}
}
if (onTriggerDesc is OnTriggerMergeDesc) {
var mergeDesc = (OnTriggerMergeDesc) onTriggerDesc;
ValidateMergeDesc(
mergeDesc,
namedWindowOrTableType,
zeroStreamAliasName,
activatorResult.ActivatorResultEventType,
streamName,
@base.StatementRawInfo,
services);
}
// validate join expression
var validatedJoin = ValidateJoinNamedWindow(
ExprNodeOrigin.WHERE,
@base.StatementSpec.Raw.WhereClause,
namedWindowOrTableType,
zeroStreamAliasName,
namedWindowTypeName,
activatorResult.ActivatorResultEventType,
streamName,
activatorResult.TriggerEventTypeName,
null,
@base.StatementRawInfo,
services);
// validate filter, output rate limiting
EPStatementStartMethodHelperValidate.ValidateNodes(
@base.StatementSpec.Raw,
typeService,
null,
@base.StatementRawInfo,
services);
// Construct a processor for results; for use in on-select to process selection results
// Use a wildcard select if the select-clause is empty, such as for on-delete.
// For on-select the select clause is not empty.
if (@base.StatementSpec.SelectClauseCompiled.SelectExprList.Length == 0) {
@base.StatementSpec.SelectClauseCompiled.WithSelectExprList(new SelectClauseElementWildcard());
}
var resultSetProcessorPrototype = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
new ResultSetSpec(@base.StatementSpec),
typeService,
null,
new bool[0],
true,
@base.ContextPropertyRegistry,
false,
true,
@base.StatementRawInfo,
services);
// plan table access
var tableAccessForges = ExprTableEvalHelperPlan.PlanTableAccess(@base.StatementSpec.TableAccessNodes);
return new OnTriggerPlanValidationResult(
subselectForges,
tableAccessForges,
resultSetProcessorPrototype,
validatedJoin,
zeroStreamAliasName);
}
public StmtForgeMethodResult Make(
string @namespace,
string classPostfix,
StatementCompileTimeServices services)
{
var statementSpec = @base.StatementSpec;
// determine context
var contextName = @base.StatementSpec.Raw.OptionalContextName;
if (contextName != null) {
throw new ExprValidationException("Update IStream is not supported in conjunction with a context");
}
var streamSpec = statementSpec.StreamSpecs[0];
var updateSpec = statementSpec.Raw.UpdateDesc;
string triggereventTypeName;
EventType streamEventType;
if (streamSpec is FilterStreamSpecCompiled) {
var filterStreamSpec = (FilterStreamSpecCompiled) streamSpec;
triggereventTypeName = filterStreamSpec.FilterSpecCompiled.FilterForEventTypeName;
streamEventType = filterStreamSpec.FilterSpecCompiled.FilterForEventType;
}
else if (streamSpec is NamedWindowConsumerStreamSpec) {
var namedSpec = (NamedWindowConsumerStreamSpec) streamSpec;
streamEventType = namedSpec.NamedWindow.EventType;
triggereventTypeName = streamEventType.Name;
}
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;
}
StreamTypeService typeService = new StreamTypeServiceImpl(
new[] {streamEventType},
new[] {streamName},
new[] {true},
false,
false);
// create subselect information
IList<FilterSpecCompiled> filterSpecCompileds = new List<FilterSpecCompiled>();
IList<NamedWindowConsumerStreamSpec> namedWindowConsumers = new List<NamedWindowConsumerStreamSpec>();
var subselectActivation = SubSelectHelperActivations.CreateSubSelectActivation(
filterSpecCompileds,
namedWindowConsumers,
@base,
services);
// handle subselects
var subselectForges = SubSelectHelperForgePlanner.PlanSubSelect(
@base,
subselectActivation,
typeService.StreamNames,
typeService.EventTypes,
new[] {triggereventTypeName},
services);
var validationContext =
new ExprValidationContextBuilder(typeService, @base.StatementRawInfo, services).Build();
foreach (var assignment in updateSpec.Assignments) {
var validated = ExprNodeUtilityValidate.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 = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.WHERE,
updateSpec.OptionalWhereClause,
validationContext);
updateSpec.OptionalWhereClause = validated;
EPStatementStartMethodHelperValidate.ValidateNoAggregations(
validated,
"Aggregation functions may not be used within an update-clause");
}
// build route information
var routerDesc = InternalEventRouterDescFactory.GetValidatePreprocessing(
streamEventType,
updateSpec,
@base.StatementRawInfo.Annotations);
var statementFieldsClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementFields), classPostfix);
var packageScope = new CodegenNamespaceScope(
@namespace,
statementFieldsClassName,
services.IsInstrumented);
var aiFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(StatementAIFactoryProvider),
classPostfix);
var forge = new StatementAgentInstanceFactoryUpdateForge(routerDesc, subselectForges);
var aiFactoryForgable = new StmtClassForgableAIFactoryProviderUpdate(
aiFactoryProviderClassName,
packageScope,
forge);
var selectSubscriberDescriptor = new SelectSubscriberDescriptor(
new[] {streamEventType.UnderlyingType},
new[] {"*"},
false,
null);
var informationals = StatementInformationalsUtil.GetInformationals(
@base,
filterSpecCompileds,
Collections.GetEmptyList<ScheduleHandleCallbackProvider>(),
Collections.GetEmptyList<NamedWindowConsumerStreamSpec>(),
false,
selectSubscriberDescriptor,
packageScope,
services);
var statementProviderClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix);
var stmtProvider = new StmtClassForgableStmtProvider(
aiFactoryProviderClassName,
statementProviderClassName,
informationals,
packageScope);
IList<StmtClassForgable> forgables = new List<StmtClassForgable>();
forgables.Add(aiFactoryForgable);
forgables.Add(stmtProvider);
forgables.Add(new StmtClassForgableStmtFields(statementFieldsClassName, packageScope, 0));
return new StmtForgeMethodResult(
forgables,
filterSpecCompileds,
Collections.GetEmptyList<ScheduleHandleCallbackProvider>(),
namedWindowConsumers,
Collections.GetEmptyList<FilterSpecParamExprNodeForge>());
}
public static OnTriggerSetPlan HandleSetVariable(
string className,
CodegenNamespaceScope namespaceScope,
string classPostfix,
OnTriggerActivatorDesc activatorResult,
string optionalStreamName,
IDictionary<ExprSubselectNode, SubSelectActivationPlan> subselectActivation,
OnTriggerSetDesc desc,
StatementBaseInfo @base,
StatementCompileTimeServices services)
{
StreamTypeService typeService = new StreamTypeServiceImpl(
new[] {activatorResult.ActivatorResultEventType},
new[] {optionalStreamName},
new[] {true},
false,
false);
var validationContext = new ExprValidationContextBuilder(typeService, @base.StatementRawInfo, services)
.WithAllowBindingConsumption(true)
.Build();
// handle subselects
var subselectForges = SubSelectHelperForgePlanner.PlanSubSelect(
@base,
subselectActivation,
new[] {optionalStreamName},
new[] {activatorResult.ActivatorResultEventType},
new[] {activatorResult.TriggerEventTypeName},
services);
// validate assignments
foreach (var assignment in desc.Assignments) {
var validated = ExprNodeUtilityValidate.GetValidatedAssignment(assignment, validationContext);
assignment.Expression = validated;
}
// create read-write logic
var variableReadWritePackageForge = new VariableReadWritePackageForge(desc.Assignments, services);
// plan table access
var tableAccessForges = ExprTableEvalHelperPlan.PlanTableAccess(@base.StatementSpec.TableAccessNodes);
// create output event type
var eventTypeName = services.EventTypeNameGeneratorStatement.AnonymousTypeName;
var eventTypeMetadata = new EventTypeMetadata(
eventTypeName,
@base.ModuleName,
EventTypeTypeClass.STATEMENTOUT,
EventTypeApplicationType.MAP,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var eventType = BaseNestableEventUtil.MakeMapTypeCompileTime(
eventTypeMetadata,
variableReadWritePackageForge.VariableTypes,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(eventType);
// Handle output format
var defaultSelectAllSpec = new StatementSpecCompiled();
defaultSelectAllSpec.SelectClauseCompiled.WithSelectExprList(new SelectClauseElementWildcard());
defaultSelectAllSpec.Raw.SelectStreamDirEnum = SelectClauseStreamSelectorEnum.RSTREAM_ISTREAM_BOTH;
StreamTypeService streamTypeService = new StreamTypeServiceImpl(
new EventType[] {eventType},
new[] {"trigger_stream"},
new[] {true},
false,
false);
var resultSetProcessor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
new ResultSetSpec(defaultSelectAllSpec),
streamTypeService,
null,
new bool[1],
false,
@base.ContextPropertyRegistry,
false,
false,
@base.StatementRawInfo,
services);
var classNameRSP = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(ResultSetProcessorFactoryProvider),
classPostfix);
var forge = new StatementAgentInstanceFactoryOnTriggerSetForge(
activatorResult.Activator,
eventType,
subselectForges,
tableAccessForges,
variableReadWritePackageForge,
classNameRSP);
IList<StmtClassForgable> forgables = new List<StmtClassForgable>();
forgables.Add(
new StmtClassForgableRSPFactoryProvider(
classNameRSP,
resultSetProcessor,
namespaceScope,
@base.StatementRawInfo));
var onTrigger = new StmtClassForgableAIFactoryProviderOnTrigger(className, namespaceScope, forge);
return new OnTriggerSetPlan(onTrigger, forgables, resultSetProcessor.SelectSubscriberDescriptor);
}
