public void TestGetProcessorSimpleSelect()
{
// empty group-by and no event properties aggregated in select clause (wildcard), no having clause
var wildcardSelect = new SelectClauseElementCompiled[] { new SelectClauseElementWildcard() };
var spec = MakeSpec(new SelectClauseSpecCompiled(wildcardSelect, false), null, _groupByList, null, null, _orderByList);
var processor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
spec, _stmtContext, _typeService3Stream,
null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY,
null, new Configuration(_container), null, false, false);
Assert.IsTrue(processor.ResultSetProcessorFactory is ResultSetProcessorHandThroughFactory);
// empty group-by with select clause elements
var selectList = SupportSelectExprFactory.MakeNoAggregateSelectListUnnamed();
spec = MakeSpec(new SelectClauseSpecCompiled(selectList, false), null, _groupByList, null, null, _orderByList);
processor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
spec, _stmtContext, _typeService1Stream,
null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY,
null, new Configuration(_container), null, false, false);
Assert.IsTrue(processor.ResultSetProcessorFactory is ResultSetProcessorHandThroughFactory);
// non-empty group-by and wildcard select, group by ignored
_groupByList.Add(SupportExprNodeFactory.MakeIdentNode("DoubleBoxed", "s0"));
spec = MakeSpec(new SelectClauseSpecCompiled(wildcardSelect, false), null, _groupByList, null, null, _orderByList);
processor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
spec, _stmtContext, _typeService1Stream,
null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY,
null, new Configuration(_container), null, false, false);
Assert.IsTrue(processor.ResultSetProcessorFactory is ResultSetProcessorSimpleFactory);
}
public void TestGetProcessorNoProcessorRequired()
{
// single stream, empty group-by and wildcard select, no having clause, no need for any output processing
var wildcardSelect = new SelectClauseElementCompiled[] { new SelectClauseElementWildcard() };
var spec = MakeSpec(new SelectClauseSpecCompiled(wildcardSelect, false), null, _groupByList, null, null, _orderByList);
var processor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(spec, _stmtContext, _typeService1Stream, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, new Configuration());
Assert.IsTrue(processor.ResultSetProcessorFactory is ResultSetProcessorHandThroughFactory);
}
public void TestGetProcessorInvalid()
{
var spec = MakeSpec(new SelectClauseSpecCompiled(SupportSelectExprFactory.MakeInvalidSelectList(), false), null, _groupByList, null, null, _orderByList);
// invalid select clause
try
{
ResultSetProcessorFactoryFactory.GetProcessorPrototype(
spec, _stmtContext, _typeService3Stream,
null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY,
null, new Configuration(_container), null, false, false);
Assert.Fail();
}
catch (ExprValidationException)
{
// expected
}
// invalid group-by
_groupByList.Add(new ExprIdentNodeImpl("xxxx", "s0"));
try
{
spec = MakeSpec(new SelectClauseSpecCompiled(SupportSelectExprFactory.MakeNoAggregateSelectListUnnamed(), false), null, _groupByList, null, null, _orderByList);
ResultSetProcessorFactoryFactory.GetProcessorPrototype(
spec, _stmtContext, _typeService3Stream,
null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY,
null, new Configuration(_container), null, false, false);
Assert.Fail();
}
catch (ExprValidationException)
{
// expected
}
// Test group by having properties that are aggregated in select clause, should fail
_groupByList.Clear();
_groupByList.Add(SupportExprNodeFactory.MakeSumAggregateNode());
var selectList = new SelectClauseElementCompiled[] {
new SelectClauseExprCompiledSpec(SupportExprNodeFactory.MakeSumAggregateNode(), null, null, false)
};
try
{
spec = MakeSpec(new SelectClauseSpecCompiled(selectList, false), null, _groupByList, null, null, _orderByList);
ResultSetProcessorFactoryFactory.GetProcessorPrototype(
spec, _stmtContext, _typeService3Stream,
null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY,
null, new Configuration(_container), null, false, false);
Assert.Fail();
}
catch (ExprValidationException)
{
// expected
}
}
public void TestGetProcessorRowForAll()
{
// empty group-by but aggragating event properties in select clause (output per event), no having clause
// and all properties in the select clause are aggregated
var selectList = SupportSelectExprFactory.MakeAggregateSelectListWithProps();
var spec = MakeSpec(new SelectClauseSpecCompiled(selectList, false), null, _groupByList, null, null, _orderByList);
var processor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(spec, _stmtContext, _typeService1Stream, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, new Configuration());
Assert.IsTrue(processor.ResultSetProcessorFactory is ResultSetProcessorRowForAllFactory);
}
public void TestGetProcessorRowPerGroup()
{
// with group-by and the non-aggregated event properties are all listed in the group by (output per group)
// no having clause
var selectList = SupportSelectExprFactory.MakeAggregateMixed();
_groupByList.Add(SupportExprNodeFactory.MakeIdentNode("DoubleBoxed", "s0"));
var spec = MakeSpec(new SelectClauseSpecCompiled(selectList, false), null, _groupByList, null, null, _orderByList);
var processor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(spec, _stmtContext, _typeService1Stream, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, new Configuration());
Assert.IsTrue(processor.ResultSetProcessorFactory is ResultSetProcessorRowPerGroupFactory);
}
protected override StatementAgentInstanceFactoryResult NewContextInternal(AgentInstanceContext agentInstanceContext, bool isRecoveringResilient)
{
StopCallback stopCallback = new ProxyStopCallback(() => _services.VariableService.DeallocateVariableState(_variableMetaData.VariableName, agentInstanceContext.AgentInstanceId));
_services.VariableService.AllocateVariableState(
_variableMetaData.VariableName, agentInstanceContext.AgentInstanceId, _statementContext.StatementExtensionServicesContext, isRecoveringResilient);
CreateVariableView createView = new CreateVariableView(
_statementContext.StatementId,
_services.EventAdapterService,
_services.VariableService,
_createDesc.VariableName,
_statementContext.StatementResultService,
agentInstanceContext.AgentInstanceId);
_services.VariableService.RegisterCallback(_createDesc.VariableName, agentInstanceContext.AgentInstanceId, 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;
var typeService = new StreamTypeServiceImpl(new EventType[] { createView.EventType }, new string[] { "create_variable" }, new bool[] { true }, _services.EngineURI, false);
OutputProcessViewBase outputViewBase;
try {
ResultSetProcessorFactoryDesc resultSetProcessorPrototype = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
_statementSpec, _statementContext, typeService, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, _services.ConfigSnapshot, _services.ResultSetProcessorHelperFactory, false, false);
ResultSetProcessor resultSetProcessor = EPStatementStartMethodHelperAssignExpr.GetAssignResultSetProcessor(agentInstanceContext, resultSetProcessorPrototype, false, null, false);
// Attach output view
OutputProcessViewFactory outputViewFactory = OutputProcessViewFactoryFactory.Make(
_statementSpec,
_services.InternalEventRouter,
agentInstanceContext.StatementContext,
resultSetProcessor.ResultEventType, null,
_services.TableService,
resultSetProcessorPrototype.ResultSetProcessorFactory.ResultSetProcessorType,
_services.ResultSetProcessorHelperFactory,
_services.StatementVariableRefService);
outputViewBase = outputViewFactory.MakeView(resultSetProcessor, agentInstanceContext);
createView.AddView(outputViewBase);
}
catch (ExprValidationException ex)
{
throw new EPException("Unexpected exception in create-variable context allocation: " + ex.Message, ex);
}
return(new StatementAgentInstanceFactoryCreateVariableResult(outputViewBase, stopCallback, agentInstanceContext));
}
public void TestGetProcessorAggregatingAll()
{
// empty group-by but aggragating event properties in select clause (output per event), no having clause
// and one or more properties in the select clause is not aggregated
var selectList = SupportSelectExprFactory.MakeAggregateMixed();
var spec = MakeSpec(new SelectClauseSpecCompiled(selectList, false), null, _groupByList, null, null, _orderByList);
var processor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(spec, _stmtContext, _typeService1Stream, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, new Configuration());
Assert.IsTrue(processor.ResultSetProcessorFactory is ResultSetProcessorAggregateAllFactory);
// test a case where a property is both aggregated and non-aggregated: select volume, Sum(volume)
selectList = SupportSelectExprFactory.MakeAggregatePlusNoAggregate();
spec = MakeSpec(new SelectClauseSpecCompiled(selectList, false), null, _groupByList, null, null, _orderByList);
processor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(spec, _stmtContext, _typeService1Stream, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, new Configuration());
Assert.IsTrue(processor.ResultSetProcessorFactory is ResultSetProcessorAggregateAllFactory);
}
public void TestGetProcessorAggregatingGrouped()
{
// with group-by but either
// wildcard
// or one or more non-aggregated event properties are not in the group by (output per event)
var selectList = SupportSelectExprFactory.MakeAggregateMixed();
var identNode = SupportExprNodeFactory.MakeIdentNode("TheString", "s0");
selectList = (SelectClauseElementCompiled[])CollectionUtil.ArrayExpandAddSingle(selectList, new SelectClauseExprCompiledSpec(identNode, null, null, false));
_groupByList.Add(SupportExprNodeFactory.MakeIdentNode("DoubleBoxed", "s0"));
var spec = MakeSpec(new SelectClauseSpecCompiled(selectList, false), null, _groupByList, null, null, _orderByList);
var processor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(spec, _stmtContext, _typeService1Stream, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, new Configuration());
Assert.IsTrue(processor.ResultSetProcessorFactory is ResultSetProcessorAggregateGroupedFactory);
}
private static OnSplitItemForge OnSplitValidate(
StreamTypeService typeServiceTrigger,
StatementSpecCompiled statementSpecCompiled,
ContextPropertyRegistry contextPropertyRegistry,
PropertyEvaluatorForge optionalPropertyEval,
StatementRawInfo rawInfo,
StatementCompileTimeServices services)
{
var insertIntoName = statementSpecCompiled.Raw.InsertIntoDesc.EventTypeName;
var isNamedWindowInsert = services.NamedWindowCompileTimeResolver.Resolve(insertIntoName) != null;
var table = services.TableCompileTimeResolver.Resolve(insertIntoName);
EPStatementStartMethodHelperValidate.ValidateNodes(
statementSpecCompiled.Raw,
typeServiceTrigger,
null,
rawInfo,
services);
var spec = new ResultSetSpec(statementSpecCompiled);
var factoryDescs = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
spec,
typeServiceTrigger,
null,
new bool[0],
false,
contextPropertyRegistry,
false,
true,
rawInfo,
services);
return new OnSplitItemForge(
statementSpecCompiled.Raw.WhereClause,
isNamedWindowInsert,
table,
factoryDescs,
optionalPropertyEval);
}
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));
}
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 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 StmtForgeMethodResult Make(
string @namespace,
string classPostfix,
StatementCompileTimeServices services)
{
var statementSpec = _base.StatementSpec;
var createDesc = statementSpec.Raw.CreateVariableDesc;
// Check if the variable is already declared
EPLValidationUtil.ValidateAlreadyExistsTableOrVariable(
createDesc.VariableName,
services.VariableCompileTimeResolver,
services.TableCompileTimeResolver,
services.EventTypeCompileTimeResolver);
// Get assignment value when compile-time-constant
object initialValue = null;
ExprForge initialValueExpr = null;
if (createDesc.Assignment != null) {
// Evaluate assignment expression
StreamTypeService typeService = new StreamTypeServiceImpl(
new EventType[0],
new string[0],
new bool[0],
false,
false);
var validationContext =
new ExprValidationContextBuilder(typeService, _base.StatementRawInfo, services).Build();
var validated = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.VARIABLEASSIGN,
createDesc.Assignment,
validationContext);
if (validated.Forge.ForgeConstantType == ExprForgeConstantType.COMPILETIMECONST) {
initialValue = validated.Forge.ExprEvaluator.Evaluate(null, true, null);
}
createDesc.Assignment = validated;
initialValueExpr = validated.Forge;
}
var contextName = statementSpec.Raw.OptionalContextName;
NameAccessModifier? contextVisibility = null;
string contextModuleName = null;
if (contextName != null) {
var contextDetail = services.ContextCompileTimeResolver.GetContextInfo(contextName);
if (contextDetail == null) {
throw new ExprValidationException("Failed to find context '" + contextName + "'");
}
contextVisibility = contextDetail.ContextVisibility;
contextModuleName = contextDetail.ContextModuleName;
}
// get visibility
var visibility = services.ModuleVisibilityRules.GetAccessModifierVariable(_base, createDesc.VariableName);
// Compile metadata
var compileTimeConstant = createDesc.IsConstant &&
initialValueExpr != null &&
initialValueExpr.ForgeConstantType.IsCompileTimeConstant;
var metaData = VariableUtil.CompileVariable(
createDesc.VariableName,
_base.ModuleName,
visibility,
contextName,
contextVisibility,
contextModuleName,
createDesc.VariableType,
createDesc.IsConstant,
compileTimeConstant,
initialValue,
services.ImportServiceCompileTime,
EventBeanTypedEventFactoryCompileTime.INSTANCE,
services.EventTypeRepositoryPreconfigured,
services.BeanEventTypeFactoryPrivate);
// Register variable
services.VariableCompileTimeRegistry.NewVariable(metaData);
// Statement event type
var eventTypePropertyTypes = Collections.SingletonDataMap(
metaData.VariableName,
metaData.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 outputEventType = BaseNestableEventUtil.MakeMapTypeCompileTime(
eventTypeMetadata,
eventTypePropertyTypes,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(outputEventType);
// 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[] {outputEventType},
new string[] {"trigger_stream"},
new bool[] {true},
false,
false);
var resultSetProcessor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
new ResultSetSpec(defaultSelectAllSpec),
streamTypeService,
null,
new bool[1],
false,
_base.ContextPropertyRegistry,
false,
false,
_base.StatementRawInfo,
services);
// Code generation
var statementFieldsClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementFields), classPostfix);
var aiFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(StatementAIFactoryProvider),
classPostfix);
var classNameRSP = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(ResultSetProcessorFactoryProvider),
classPostfix);
var packageScope = new CodegenNamespaceScope(
@namespace,
statementFieldsClassName,
services.IsInstrumented);
var forge =
new StatementAgentInstanceFactoryCreateVariableForge(
createDesc.VariableName,
initialValueExpr,
classNameRSP);
var aiFactoryForgable = new StmtClassForgableAIFactoryProviderCreateVariable(
aiFactoryProviderClassName,
packageScope,
forge,
createDesc.VariableName);
var informationals = StatementInformationalsUtil.GetInformationals(
_base,
Collections.GetEmptyList<FilterSpecCompiled>(),
Collections.GetEmptyList<ScheduleHandleCallbackProvider>(),
Collections.GetEmptyList<NamedWindowConsumerStreamSpec>(),
true,
resultSetProcessor.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(
new StmtClassForgableRSPFactoryProvider(
classNameRSP,
resultSetProcessor,
packageScope,
_base.StatementRawInfo));
forgables.Add(aiFactoryForgable);
forgables.Add(stmtProvider);
forgables.Add(new StmtClassForgableStmtFields(statementFieldsClassName, packageScope, 0));
return new StmtForgeMethodResult(
forgables,
Collections.GetEmptyList<FilterSpecCompiled>(),
Collections.GetEmptyList<ScheduleHandleCallbackProvider>(),
Collections.GetEmptyList<NamedWindowConsumerStreamSpec>(),
Collections.GetEmptyList<FilterSpecParamExprNodeForge>());
}
public static StmtForgeMethodSelectResult Make(
IContainer container,
bool dataflowOperator,
string @namespace,
string classPostfix,
StatementBaseInfo @base,
StatementCompileTimeServices services)
{
var filterSpecCompileds = new List<FilterSpecCompiled>();
var scheduleHandleCallbackProviders = new List<ScheduleHandleCallbackProvider>();
var namedWindowConsumers = new List<NamedWindowConsumerStreamSpec>();
var statementSpec = @base.StatementSpec;
var additionalForgeables = new List<StmtClassForgeableFactory>();
var streamNames = StatementForgeMethodSelectUtil.DetermineStreamNames(statementSpec.StreamSpecs);
var numStreams = streamNames.Length;
if (numStreams == 0) {
throw new ExprValidationException("The from-clause is required but has not been specified");
}
// first we create streams for subselects, if there are any
SubSelectActivationDesc subSelectActivationDesc = SubSelectHelperActivations.CreateSubSelectActivation(
filterSpecCompileds, namedWindowConsumers, @base, services);
IDictionary<ExprSubselectNode, SubSelectActivationPlan> subselectActivation = subSelectActivationDesc.Subselects;
additionalForgeables.AddAll(subSelectActivationDesc.AdditionalForgeables);
// verify for joins that required views are present
StreamJoinAnalysisResultCompileTime joinAnalysisResult = StatementForgeMethodSelectUtil.VerifyJoinViews(statementSpec);
var streamEventTypes = new EventType[statementSpec.StreamSpecs.Length];
var eventTypeNames = new string[numStreams];
var isNamedWindow = new bool[numStreams];
var viewableActivatorForges = new ViewableActivatorForge[numStreams];
var viewForges = new IList<ViewFactoryForge>[numStreams];
var historicalEventViewables = new HistoricalEventViewableForge[numStreams];
for (var stream = 0; stream < numStreams; stream++) {
var streamSpec = statementSpec.StreamSpecs[stream];
var isCanIterateUnbound = streamSpec.ViewSpecs.Length == 0 &&
(services.Configuration.Compiler.ViewResources.IsIterableUnbound ||
AnnotationUtil.HasAnnotation(statementSpec.Annotations, typeof(IterableUnboundAttribute)));
var args = new ViewFactoryForgeArgs(
stream,
false,
-1,
streamSpec.Options,
null,
@base.StatementRawInfo,
services);
if (dataflowOperator) {
var dfResult = HandleDataflowActivation(args, streamSpec);
streamEventTypes[stream] = dfResult.StreamEventType;
eventTypeNames[stream] = dfResult.EventTypeName;
viewableActivatorForges[stream] = dfResult.ViewableActivatorForge;
viewForges[stream] = dfResult.ViewForges;
additionalForgeables.AddAll(dfResult.AdditionalForgeables);
}
else if (streamSpec is FilterStreamSpecCompiled) {
var filterStreamSpec = (FilterStreamSpecCompiled) statementSpec.StreamSpecs[stream];
var filterSpecCompiled = filterStreamSpec.FilterSpecCompiled;
streamEventTypes[stream] = filterSpecCompiled.ResultEventType;
eventTypeNames[stream] = filterStreamSpec.FilterSpecCompiled.FilterForEventTypeName;
viewableActivatorForges[stream] = new ViewableActivatorFilterForge(
filterSpecCompiled,
isCanIterateUnbound,
stream,
false,
-1);
ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(streamSpec.ViewSpecs, args, streamEventTypes[stream]);
viewForges[stream] = viewForgeDesc.Forges;
additionalForgeables.AddAll(viewForgeDesc.MultikeyForges);
filterSpecCompileds.Add(filterSpecCompiled);
}
else if (streamSpec is PatternStreamSpecCompiled) {
var patternStreamSpec = (PatternStreamSpecCompiled) streamSpec;
var forges = patternStreamSpec.Root.CollectFactories();
foreach (var forgeNode in forges) {
forgeNode.CollectSelfFilterAndSchedule(filterSpecCompileds, scheduleHandleCallbackProviders);
}
var patternType = ViewableActivatorPatternForge.MakeRegisterPatternType(
@base,
stream,
patternStreamSpec,
services);
var patternContext = new PatternContext(0, patternStreamSpec.MatchedEventMapMeta, false, -1, false);
viewableActivatorForges[stream] = new ViewableActivatorPatternForge(
patternType,
patternStreamSpec,
patternContext,
isCanIterateUnbound);
streamEventTypes[stream] = patternType;
ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(streamSpec.ViewSpecs, args, patternType);
viewForges[stream] = viewForgeDesc.Forges;
additionalForgeables.AddAll(viewForgeDesc.MultikeyForges);
}
else if (streamSpec is NamedWindowConsumerStreamSpec) {
var namedSpec = (NamedWindowConsumerStreamSpec) streamSpec;
var namedWindow =
services.NamedWindowCompileTimeResolver.Resolve(namedSpec.NamedWindow.EventType.Name);
var namedWindowType = namedWindow.EventType;
if (namedSpec.OptPropertyEvaluator != null) {
namedWindowType = namedSpec.OptPropertyEvaluator.FragmentEventType;
}
var typesFilterValidation = new StreamTypeServiceImpl(
namedWindowType,
namedSpec.OptionalStreamName,
false);
var filterSingle =
ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(namedSpec.FilterExpressions);
var filterQueryGraph = EPLValidationUtil.ValidateFilterGetQueryGraphSafe(
filterSingle,
typesFilterValidation,
@base.StatementRawInfo,
services);
namedWindowConsumers.Add(namedSpec);
viewableActivatorForges[stream] = new ViewableActivatorNamedWindowForge(
namedSpec,
namedWindow,
filterSingle,
filterQueryGraph,
true,
namedSpec.OptPropertyEvaluator);
streamEventTypes[stream] = namedWindowType;
viewForges[stream] = Collections.GetEmptyList<ViewFactoryForge>();
joinAnalysisResult.SetNamedWindowsPerStream(stream, namedWindow);
eventTypeNames[stream] = namedSpec.NamedWindow.EventType.Name;
isNamedWindow[stream] = true;
// Consumers to named windows cannot declare a data window view onto the named window to avoid duplicate remove streams
ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(streamSpec.ViewSpecs, args, namedWindowType);
viewForges[stream] = viewForgeDesc.Forges;
additionalForgeables.AddAll(viewForgeDesc.MultikeyForges);
EPStatementStartMethodHelperValidate.ValidateNoDataWindowOnNamedWindow(viewForges[stream]);
}
else if (streamSpec is TableQueryStreamSpec) {
ValidateNoViews(streamSpec, "Table data");
var tableStreamSpec = (TableQueryStreamSpec) streamSpec;
if (numStreams > 1 && 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 table = tableStreamSpec.Table;
EPLValidationUtil.ValidateContextName(
true,
table.TableName,
table.OptionalContextName,
statementSpec.Raw.OptionalContextName,
false);
var filter =
ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(tableStreamSpec.FilterExpressions);
viewableActivatorForges[stream] = new ViewableActivatorTableForge(table, filter);
viewForges[stream] = Collections.GetEmptyList<ViewFactoryForge>();
eventTypeNames[stream] = tableStreamSpec.Table.TableName;
streamEventTypes[stream] = tableStreamSpec.Table.InternalEventType;
joinAnalysisResult.SetTablesForStream(stream, table);
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");
}
}
else if (streamSpec is DBStatementStreamSpec) {
ValidateNoViews(streamSpec, "Historical data");
var sqlStreamSpec = (DBStatementStreamSpec) streamSpec;
var typeConversionHook = (SQLColumnTypeConversion) ImportUtil.GetAnnotationHook(
statementSpec.Annotations,
HookType.SQLCOL,
typeof(SQLColumnTypeConversion),
services.ImportServiceCompileTime);
var outputRowConversionHook = (SQLOutputRowConversion) ImportUtil.GetAnnotationHook(
statementSpec.Annotations,
HookType.SQLROW,
typeof(SQLOutputRowConversion),
services.ImportServiceCompileTime);
var viewable = HistoricalEventViewableDatabaseForgeFactory.CreateDBStatementView(
stream,
sqlStreamSpec,
typeConversionHook,
outputRowConversionHook,
@base,
services,
statementSpec.Annotations);
streamEventTypes[stream] = viewable.EventType;
viewForges[stream] = Collections.GetEmptyList<ViewFactoryForge>();
viewableActivatorForges[stream] = new ViewableActivatorHistoricalForge(viewable);
historicalEventViewables[stream] = viewable;
}
else if (streamSpec is MethodStreamSpec) {
ValidateNoViews(streamSpec, "Method data");
var methodStreamSpec = (MethodStreamSpec) streamSpec;
var viewable = HistoricalEventViewableMethodForgeFactory.CreateMethodStatementView(
stream,
methodStreamSpec,
@base,
services);
historicalEventViewables[stream] = viewable;
streamEventTypes[stream] = viewable.EventType;
viewForges[stream] = Collections.GetEmptyList<ViewFactoryForge>();
viewableActivatorForges[stream] = new ViewableActivatorHistoricalForge(viewable);
historicalEventViewables[stream] = viewable;
}
else {
throw new IllegalStateException("Unrecognized stream " + streamSpec);
}
// plan serde for iterate-unbound
if (isCanIterateUnbound) {
var serdeForgeables = SerdeEventTypeUtility.Plan(
streamEventTypes[stream], @base.StatementRawInfo, services.SerdeEventTypeRegistry, services.SerdeResolver);
additionalForgeables.AddAll(serdeForgeables);
}
}
// handle match-recognize pattern
if (statementSpec.Raw.MatchRecognizeSpec != null) {
if (numStreams > 1) {
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 = viewForges[0].IsEmpty() &&
!(statementSpec.StreamSpecs[0] is NamedWindowConsumerStreamSpec);
var eventType = viewForges[0].IsEmpty()
? streamEventTypes[0]
: viewForges[0][(viewForges[0].Count - 1)].EventType;
var plan = RowRecogNFAViewPlanUtil.ValidateAndPlan(services.Container, eventType, isUnbound, @base, services);
var forge = new RowRecogNFAViewFactoryForge(plan.Forge);
additionalForgeables.AddAll(plan.AdditionalForgeables);
scheduleHandleCallbackProviders.Add(forge);
viewForges[0].Add(forge);
var serdeForgeables = SerdeEventTypeUtility.Plan(
eventType, @base.StatementRawInfo, services.SerdeEventTypeRegistry, services.SerdeResolver);
additionalForgeables.AddAll(serdeForgeables);
}
// Obtain event types from view factory chains
for (var i = 0; i < viewForges.Length; i++) {
streamEventTypes[i] = viewForges[i].IsEmpty()
? streamEventTypes[i]
: viewForges[i][(viewForges[i].Count - 1)].EventType;
}
// add unique-information to join analysis
joinAnalysisResult.AddUniquenessInfo(viewForges, statementSpec.Annotations);
// plan sub-selects
SubSelectHelperForgePlan subselectForgePlan = SubSelectHelperForgePlanner.PlanSubSelect(
@base, subselectActivation, streamNames, streamEventTypes, eventTypeNames, services);
var subselectForges = subselectForgePlan.Subselects;
additionalForgeables.AddAll(subselectForgePlan.AdditionalForgeables);
DetermineViewSchedules(subselectForges, scheduleHandleCallbackProviders);
// determine view schedules
var viewResourceDelegateExpr = new ViewResourceDelegateExpr();
ViewFactoryForgeUtil.DetermineViewSchedules(viewForges, scheduleHandleCallbackProviders);
var hasIStreamOnly = StatementForgeMethodSelectUtil.GetHasIStreamOnly(isNamedWindow, viewForges);
var optionalStreamsIfAny = OuterJoinAnalyzer.OptionalStreamsIfAny(statementSpec.Raw.OuterJoinDescList);
StreamTypeService typeService = new StreamTypeServiceImpl(
streamEventTypes,
streamNames,
hasIStreamOnly,
false,
optionalStreamsIfAny);
// 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;
}
scheduleHandleCallbackProviders.Add(historicalEventViewable);
IList<StmtClassForgeableFactory> forgeables = historicalEventViewable.Validate(typeService, @base, services);
additionalForgeables.AddAll(forgeables);
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");
}
}
// Validate where-clause filter tree, outer join clause and output limit expression
var whereClauseValidated = EPStatementStartMethodHelperValidate.ValidateNodes(
statementSpec.Raw,
typeService,
viewResourceDelegateExpr,
@base.StatementRawInfo,
services);
var whereClauseForge = whereClauseValidated?.Forge;
// Obtain result set processor
var resultSetProcessorDesc = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
new ResultSetSpec(statementSpec),
typeService,
viewResourceDelegateExpr,
joinAnalysisResult.UnidirectionalInd,
true,
@base.ContextPropertyRegistry,
false,
false,
@base.StatementRawInfo,
services);
additionalForgeables.AddAll(resultSetProcessorDesc.AdditionalForgeables);
// Handle 'prior' function nodes in terms of view requirements
var viewResourceDelegateDesc =
ViewResourceVerifyHelper.VerifyPreviousAndPriorRequirements(viewForges, viewResourceDelegateExpr);
var hasPrior = ViewResourceDelegateDesc.HasPrior(viewResourceDelegateDesc);
if (hasPrior) {
for (var stream = 0; stream < numStreams; stream++) {
if (!viewResourceDelegateDesc[stream].PriorRequests.IsEmpty()) {
viewForges[stream].Add(new PriorEventViewForge(viewForges[stream].IsEmpty(), streamEventTypes[stream]));
var serdeForgeables = SerdeEventTypeUtility.Plan(
streamEventTypes[stream], @base.StatementRawInfo, services.SerdeEventTypeRegistry, services.SerdeResolver);
additionalForgeables.AddAll(serdeForgeables);
}
}
}
var outputProcessDesc = OutputProcessViewForgeFactory.Make(
typeService.EventTypes,
resultSetProcessorDesc.ResultEventType,
resultSetProcessorDesc.ResultSetProcessorType,
statementSpec,
@base.StatementRawInfo,
services);
var outputProcessViewFactoryForge = outputProcessDesc.Forge;
additionalForgeables.AddAll(outputProcessDesc.AdditionalForgeables);
outputProcessViewFactoryForge.CollectSchedules(scheduleHandleCallbackProviders);
JoinSetComposerPrototypeForge joinForge = null;
if (numStreams > 1) {
var hasAggregations = !resultSetProcessorDesc.AggregationServiceForgeDesc.Expressions.IsEmpty();
var desc = JoinSetComposerPrototypeForgeFactory.MakeComposerPrototype(
statementSpec,
joinAnalysisResult,
typeService,
historicalViewableDesc,
false,
hasAggregations,
@base.StatementRawInfo,
services);
joinForge = desc.Forge;
additionalForgeables.AddAll(desc.AdditionalForgeables);
HandleIndexDependencies(joinForge.OptionalQueryPlan, services);
}
// plan table access
var tableAccessForges =
ExprTableEvalHelperPlan.PlanTableAccess(@base.StatementSpec.TableAccessNodes);
ValidateTableAccessUse(statementSpec.Raw.IntoTableSpec, statementSpec.Raw.TableExpressions);
if (joinAnalysisResult.IsUnidirectional && statementSpec.Raw.IntoTableSpec != null) {
throw new ExprValidationException("Into-table does not allow unidirectional joins");
}
var orderByWithoutOutputLimit = statementSpec.Raw.OrderByList != null &&
!statementSpec.Raw.OrderByList.IsEmpty() &&
statementSpec.Raw.OutputLimitSpec == null;
var statementAIFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(StatementAIFactoryProvider),
classPostfix);
var resultSetProcessorProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(ResultSetProcessorFactoryProvider),
classPostfix);
var outputProcessViewProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(OutputProcessViewFactoryProvider),
classPostfix);
var statementProviderClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix);
var statementFieldsClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementFields), classPostfix);
//var statementFieldsClassName = namespaceScope.FieldsClassNameOptional;
var forgeX = new StatementAgentInstanceFactorySelectForge(
typeService.StreamNames,
viewableActivatorForges,
resultSetProcessorProviderClassName,
viewForges,
viewResourceDelegateDesc,
whereClauseForge,
joinForge,
outputProcessViewProviderClassName,
subselectForges,
tableAccessForges,
orderByWithoutOutputLimit,
joinAnalysisResult.IsUnidirectional);
var namespaceScope = new CodegenNamespaceScope(
@namespace,
statementFieldsClassName,
services.IsInstrumented);
var forgeablesX = additionalForgeables
.Select(additional => additional.Make(namespaceScope, classPostfix))
.ToList();
forgeablesX.Add(
new StmtClassForgeableRSPFactoryProvider(
resultSetProcessorProviderClassName,
resultSetProcessorDesc,
namespaceScope,
@base.StatementRawInfo));
forgeablesX.Add(
new StmtClassForgeableOPVFactoryProvider(
outputProcessViewProviderClassName,
outputProcessViewFactoryForge,
namespaceScope,
numStreams,
@base.StatementRawInfo));
forgeablesX.Add(
new StmtClassForgeableAIFactoryProviderSelect(statementAIFactoryProviderClassName, namespaceScope, forgeX));
forgeablesX.Add(
new StmtClassForgeableStmtFields(statementFieldsClassName, namespaceScope, numStreams));
if (!dataflowOperator) {
var informationals = StatementInformationalsUtil.GetInformationals(
@base,
filterSpecCompileds,
scheduleHandleCallbackProviders,
namedWindowConsumers,
true,
resultSetProcessorDesc.SelectSubscriberDescriptor,
namespaceScope,
services);
forgeablesX.Add(
new StmtClassForgeableStmtProvider(statementAIFactoryProviderClassName, statementProviderClassName, informationals, namespaceScope));
}
var forgeableResult = new StmtForgeMethodResult(
forgeablesX,
filterSpecCompileds,
scheduleHandleCallbackProviders,
namedWindowConsumers,
FilterSpecCompiled.MakeExprNodeList(filterSpecCompileds, EmptyList<FilterSpecParamExprNodeForge>.Instance));
return new StmtForgeMethodSelectResult(forgeableResult, resultSetProcessorDesc.ResultEventType, numStreams);
}
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);
}
private StmtForgeMethodResult Build(
string @namespace,
string classPostfix,
StatementCompileTimeServices services)
{
var compileResult = CreateWindowUtil.HandleCreateWindow(@base, services);
var namedWindowType = compileResult.FilterSpecCompiled.FilterForEventType;
// view must be non-empty list
var createWindowDesc = @base.StatementSpec.Raw.CreateWindowDesc;
if (createWindowDesc.ViewSpecs.IsEmpty()) {
throw new ExprValidationException(NamedWindowManagementServiceConstants.ERROR_MSG_DATAWINDOWS);
}
if (services.NamedWindowCompileTimeResolver.Resolve(createWindowDesc.WindowName) != null) {
throw new ExprValidationException(
"Named window named '" + createWindowDesc.WindowName + "' has already been declared");
}
// build forge
var activator = new ViewableActivatorFilterForge(compileResult.FilterSpecCompiled, false, 0, false, -1);
var viewSpecs = createWindowDesc.ViewSpecs;
var viewArgs = new ViewFactoryForgeArgs(
0,
false,
-1,
createWindowDesc.StreamSpecOptions,
createWindowDesc.WindowName,
@base.StatementRawInfo,
services);
var viewForges = ViewFactoryForgeUtil.CreateForges(viewSpecs.ToArray(), viewArgs, namedWindowType);
IList<ScheduleHandleCallbackProvider> schedules = new List<ScheduleHandleCallbackProvider>();
ViewFactoryForgeUtil.DetermineViewSchedules(viewForges, schedules);
VerifyDataWindowViewFactoryChain(viewForges);
var optionalUniqueKeyProps =
StreamJoinAnalysisResultCompileTime.GetUniqueCandidateProperties(
viewForges,
@base.StatementSpec.Annotations);
var uniqueKeyProArray = optionalUniqueKeyProps == null ? null : optionalUniqueKeyProps.ToArray();
NamedWindowMetaData insertFromNamedWindow = null;
ExprNode insertFromFilter = null;
if (createWindowDesc.IsInsert || createWindowDesc.InsertFilter != null) {
var name = createWindowDesc.AsEventTypeName;
insertFromNamedWindow = services.NamedWindowCompileTimeResolver.Resolve(name);
if (insertFromNamedWindow == null) {
throw new ExprValidationException(
"A named window by name '" +
name +
"' could not be located, the insert-keyword requires an existing named window");
}
insertFromFilter = createWindowDesc.InsertFilter;
if (insertFromFilter != null) {
var checkMinimal = ExprNodeUtilityValidate.IsMinimalExpression(insertFromFilter);
if (checkMinimal != null) {
throw new ExprValidationException("Create window where-clause may not have " + checkMinimal);
}
StreamTypeService streamTypeService = new StreamTypeServiceImpl(
insertFromNamedWindow.EventType,
name,
true);
var validationContext = new ExprValidationContextBuilder(
streamTypeService,
@base.StatementRawInfo,
services).Build();
insertFromFilter = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.CREATEWINDOWFILTER,
insertFromFilter,
validationContext);
}
}
// handle output format
var defaultSelectAllSpec = new StatementSpecCompiled();
defaultSelectAllSpec.SelectClauseCompiled.WithSelectExprList(new SelectClauseElementWildcard());
defaultSelectAllSpec.Raw.SelectStreamDirEnum = SelectClauseStreamSelectorEnum.RSTREAM_ISTREAM_BOTH;
StreamTypeService typeService = new StreamTypeServiceImpl(
new[] {namedWindowType},
new[] {createWindowDesc.WindowName},
new[] {true},
false,
false);
var resultSetProcessor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
new ResultSetSpec(defaultSelectAllSpec),
typeService,
null,
new bool[1],
false,
@base.ContextPropertyRegistry,
false,
false,
@base.StatementRawInfo,
services);
var classNameRSP = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(ResultSetProcessorFactoryProvider),
classPostfix);
var selectSubscriberDescriptor = resultSetProcessor.SelectSubscriberDescriptor;
var forge = new StatementAgentInstanceFactoryCreateNWForge(
activator,
createWindowDesc.WindowName,
viewForges,
insertFromNamedWindow,
insertFromFilter,
compileResult.AsEventType,
classNameRSP);
// add named window
var isBatchingDataWindow = DetermineBatchingDataWindow(viewForges);
var virtualDataWindow = viewForges[0] is VirtualDWViewFactoryForge;
var isEnableIndexShare = virtualDataWindow ||
HintEnum.ENABLE_WINDOW_SUBQUERY_INDEXSHARE.GetHint(
@base.StatementSpec.Annotations) !=
null;
var metaData = new NamedWindowMetaData(
namedWindowType,
@base.ModuleName,
@base.ContextName,
uniqueKeyProArray,
isBatchingDataWindow,
isEnableIndexShare,
compileResult.AsEventType,
virtualDataWindow);
services.NamedWindowCompileTimeRegistry.NewNamedWindow(metaData);
// build forge list
IList<StmtClassForgable> forgables = new List<StmtClassForgable>(2);
var statementFieldsClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementFields), classPostfix);
var packageScope = new CodegenNamespaceScope(
@namespace,
statementFieldsClassName,
services.IsInstrumented);
forgables.Add(
new StmtClassForgableRSPFactoryProvider(
classNameRSP,
resultSetProcessor,
packageScope,
@base.StatementRawInfo));
var aiFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(StatementAIFactoryProvider),
classPostfix);
var aiFactoryForgable = new StmtClassForgableAIFactoryProviderCreateNW(
aiFactoryProviderClassName,
packageScope,
forge,
createWindowDesc.WindowName);
forgables.Add(aiFactoryForgable);
var statementProviderClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix);
var informationals = StatementInformationalsUtil.GetInformationals(
@base,
Collections.SingletonList(compileResult.FilterSpecCompiled),
schedules,
new EmptyList<NamedWindowConsumerStreamSpec>(),
true,
selectSubscriberDescriptor,
packageScope,
services);
forgables.Add(
new StmtClassForgableStmtProvider(
aiFactoryProviderClassName,
statementProviderClassName,
informationals,
packageScope));
forgables.Add(new StmtClassForgableStmtFields(statementFieldsClassName, packageScope, 1));
return new StmtForgeMethodResult(
forgables,
Collections.SingletonList(compileResult.FilterSpecCompiled),
schedules,
new EmptyList<NamedWindowConsumerStreamSpec>(),
new EmptyList<FilterSpecParamExprNodeForge>());
}
public static OnTriggerPlan HandleContextFactoryOnTrigger(
string className,
CodegenNamespaceScope namespaceScope,
string classPostfix,
NamedWindowMetaData namedWindow,
TableMetaData table,
OnTriggerWindowPlan planDesc,
StatementBaseInfo @base,
StatementCompileTimeServices services)
{
// validate context
var infraName = planDesc.OnTriggerDesc.WindowName;
var infraTitle = (namedWindow != null ? "Named window" : "Table") + " '" + infraName + "'";
var infraContextName = namedWindow != null ? namedWindow.ContextName : table.OptionalContextName;
var infraModuleName = namedWindow != null ? namedWindow.NamedWindowModuleName : table.TableModuleName;
var infraEventType = namedWindow != null ? namedWindow.EventType : table.InternalEventType;
var resultEventType = namedWindow != null ? namedWindow.EventType : table.PublicEventType;
var infraVisibility = namedWindow != null
? namedWindow.EventType.Metadata.AccessModifier
: table.TableVisibility;
ValidateOnExpressionContext(planDesc.ContextName, infraContextName, infraTitle);
List<StmtClassForgeableFactory> additionalForgeables = new List<StmtClassForgeableFactory>();
// validate expressions and plan subselects
var validationResult = OnTriggerPlanValidator.ValidateOnTriggerPlan(
infraEventType,
planDesc.OnTriggerDesc,
planDesc.StreamSpec,
planDesc.ActivatorResult,
planDesc.SubselectActivation,
@base,
services);
additionalForgeables.AddAll(validationResult.AdditionalForgeables);
var validatedJoin = validationResult.ValidatedJoin;
var activatorResultEventType = planDesc.ActivatorResult.ActivatorResultEventType;
var pair = IndexHintPair.GetIndexHintPair(
planDesc.OnTriggerDesc,
@base.StatementSpec.StreamSpecs[0].OptionalStreamName,
@base.StatementRawInfo,
services);
var indexHint = pair.IndexHint;
var excludePlanHint = pair.ExcludePlanHint;
var enabledSubqueryIndexShare = namedWindow != null && namedWindow.IsEnableIndexShare;
var isVirtualWindow = namedWindow != null && namedWindow.IsVirtualDataWindow;
var indexMetadata = namedWindow != null ? namedWindow.IndexMetadata : table.IndexMetadata;
var optionalUniqueKeySet = namedWindow != null ? namedWindow.UniquenessAsSet : table.UniquenessAsSet;
// query plan
var onlyUseExistingIndexes = table != null;
SubordinateWMatchExprQueryPlanResult planResult = SubordinateQueryPlanner.PlanOnExpression(
validatedJoin,
activatorResultEventType,
indexHint,
enabledSubqueryIndexShare,
-1,
excludePlanHint,
isVirtualWindow,
indexMetadata,
infraEventType,
optionalUniqueKeySet,
onlyUseExistingIndexes,
@base.StatementRawInfo,
services);
SubordinateWMatchExprQueryPlanForge queryPlan = planResult.Forge;
additionalForgeables.AddAll(planResult.AdditionalForgeables);
// indicate index dependencies
if (queryPlan.Indexes != null && infraVisibility == NameAccessModifier.PUBLIC) {
foreach (var index in queryPlan.Indexes) {
services.ModuleDependenciesCompileTime.AddPathIndex(
namedWindow != null,
infraName,
infraModuleName,
index.IndexName,
index.IndexModuleName,
services.NamedWindowCompileTimeRegistry,
services.TableCompileTimeRegistry);
}
}
var onTriggerType = planDesc.OnTriggerDesc.OnTriggerType;
var activator = planDesc.ActivatorResult.Activator;
var subselectForges = validationResult.SubselectForges;
var tableAccessForges = validationResult.TableAccessForges;
IList<StmtClassForgeable> forgeables = new List<StmtClassForgeable>(2);
StatementAgentInstanceFactoryOnTriggerInfraBaseForge forge;
var classNameRSP = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(ResultSetProcessorFactoryProvider),
classPostfix);
ResultSetProcessorDesc resultSetProcessor;
if (onTriggerType == OnTriggerType.ON_SELECT) {
resultSetProcessor = validationResult.ResultSetProcessorPrototype;
var outputEventType = resultSetProcessor.ResultEventType;
var insertInto = false;
TableMetaData optionalInsertIntoTable = null;
var insertIntoDesc = @base.StatementSpec.Raw.InsertIntoDesc;
var addToFront = false;
if (insertIntoDesc != null) {
insertInto = true;
optionalInsertIntoTable = services.TableCompileTimeResolver.Resolve(insertIntoDesc.EventTypeName);
var optionalInsertIntoNamedWindow =
services.NamedWindowCompileTimeResolver.Resolve(insertIntoDesc.EventTypeName);
addToFront = optionalInsertIntoNamedWindow != null || optionalInsertIntoTable != null;
}
var selectAndDelete = planDesc.OnTriggerDesc.IsDeleteAndSelect;
var distinct = @base.StatementSpec.SelectClauseCompiled.IsDistinct;
MultiKeyPlan distinctMultiKeyPlan = MultiKeyPlanner.PlanMultiKeyDistinct(
distinct,
outputEventType,
@base.StatementRawInfo,
services.SerdeResolver);
additionalForgeables.AddAll(distinctMultiKeyPlan.MultiKeyForgeables);
forge = new StatementAgentInstanceFactoryOnTriggerInfraSelectForge(
activator,
outputEventType,
subselectForges,
tableAccessForges,
namedWindow,
table,
queryPlan,
classNameRSP,
insertInto,
addToFront,
optionalInsertIntoTable,
selectAndDelete,
distinct,
distinctMultiKeyPlan.ClassRef);
}
else {
var defaultSelectAllSpec = new StatementSpecCompiled();
defaultSelectAllSpec.SelectClauseCompiled.WithSelectExprList(new SelectClauseElementWildcard());
defaultSelectAllSpec.Raw.SelectStreamDirEnum = SelectClauseStreamSelectorEnum.RSTREAM_ISTREAM_BOTH;
StreamTypeService typeService = new StreamTypeServiceImpl(
new[] {resultEventType},
new[] {infraName},
new[] {false},
false,
false);
resultSetProcessor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
new ResultSetSpec(defaultSelectAllSpec),
typeService,
null,
new bool[1],
false,
@base.ContextPropertyRegistry,
false,
false,
@base.StatementRawInfo,
services);
if (onTriggerType == OnTriggerType.ON_DELETE) {
forge = new StatementAgentInstanceFactoryOnTriggerInfraDeleteForge(
activator,
resultEventType,
subselectForges,
tableAccessForges,
classNameRSP,
namedWindow,
table,
queryPlan);
}
else if (onTriggerType == OnTriggerType.ON_UPDATE) {
var updateDesc = (OnTriggerWindowUpdateDesc) planDesc.OnTriggerDesc;
EventBeanUpdateHelperForge updateHelper = EventBeanUpdateHelperForgeFactory.Make(
infraName,
(EventTypeSPI) infraEventType,
updateDesc.Assignments,
validationResult.ZeroStreamAliasName,
activatorResultEventType,
namedWindow != null,
@base.StatementName,
services.EventTypeAvroHandler);
forge = new StatementAgentInstanceFactoryOnTriggerInfraUpdateForge(
activator,
resultEventType,
subselectForges,
tableAccessForges,
classNameRSP,
namedWindow,
table,
queryPlan,
updateHelper);
}
else if (onTriggerType == OnTriggerType.ON_MERGE) {
var onMergeTriggerDesc = (OnTriggerMergeDesc) planDesc.OnTriggerDesc;
var onMergeHelper = new InfraOnMergeHelperForge(
onMergeTriggerDesc,
activatorResultEventType,
planDesc.StreamSpec.OptionalStreamName,
infraName,
(EventTypeSPI) infraEventType,
@base.StatementRawInfo,
services,
table);
forge = new StatementAgentInstanceFactoryOnTriggerInfraMergeForge(
activator,
resultEventType,
subselectForges,
tableAccessForges,
classNameRSP,
namedWindow,
table,
queryPlan,
onMergeHelper);
}
else {
throw new IllegalStateException("Unrecognized trigger type " + onTriggerType);
}
}
forgeables.Add(
new StmtClassForgeableRSPFactoryProvider(
classNameRSP,
resultSetProcessor,
namespaceScope,
@base.StatementRawInfo));
var queryPlanLogging = services.Configuration.Common.Logging.IsEnableQueryPlan;
SubordinateQueryPlannerUtil.QueryPlanLogOnExpr(
queryPlanLogging,
QUERY_PLAN_LOG,
queryPlan,
@base.StatementSpec.Annotations,
services.ImportServiceCompileTime);
StmtClassForgeableAIFactoryProviderOnTrigger onTrigger = new StmtClassForgeableAIFactoryProviderOnTrigger(className, namespaceScope, forge);
return new OnTriggerPlan(onTrigger, forgeables, resultSetProcessor.SelectSubscriberDescriptor, additionalForgeables);
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="statementSpec">is a container for the definition of all statement constructs thatmay have been used in the statement, i.e. if defines the select clauses, insert into, outer joins etc.
/// </param>
/// <param name="services">is the service instances for dependency injection</param>
/// <param name="statementContext">is statement-level information and statement services</param>
/// <throws>ExprValidationException if the preparation failed</throws>
public EPPreparedExecuteMethodQuery(StatementSpecCompiled statementSpec,
EPServicesContext services,
StatementContext statementContext)
{
var queryPlanLogging = services.ConfigSnapshot.EngineDefaults.LoggingConfig.IsEnableQueryPlan;
if (queryPlanLogging)
{
QueryPlanLog.Info("Query plans for Fire-and-forget query '" + statementContext.Expression + "'");
}
_hasTableAccess = (statementSpec.TableNodes != null && statementSpec.TableNodes.Length > 0);
foreach (var streamSpec in statementSpec.StreamSpecs)
{
_hasTableAccess |= streamSpec is TableQueryStreamSpec;
}
_statementSpec = statementSpec;
_services = services;
EPPreparedExecuteMethodHelper.ValidateFAFQuery(statementSpec);
var numStreams = statementSpec.StreamSpecs.Length;
var typesPerStream = new EventType[numStreams];
var namesPerStream = new string[numStreams];
_processors = new FireAndForgetProcessor[numStreams];
_agentInstanceContext = new AgentInstanceContext(statementContext, null, -1, null, null, statementContext.DefaultAgentInstanceScriptContext);
// resolve types and processors
for (var i = 0; i < numStreams; i++)
{
var streamSpec = statementSpec.StreamSpecs[i];
_processors[i] = FireAndForgetProcessorFactory.ValidateResolveProcessor(streamSpec, services);
string streamName = _processors[i].NamedWindowOrTableName;
if (streamSpec.OptionalStreamName != null)
{
streamName = streamSpec.OptionalStreamName;
}
namesPerStream[i] = streamName;
typesPerStream[i] = _processors[i].EventTypeResultSetProcessor;
}
// compile filter to optimize access to named window
_filters = new FilterSpecCompiled[numStreams];
if (statementSpec.FilterRootNode != null)
{
var tagged = new LinkedHashMap <string, Pair <EventType, string> >();
for (var i = 0; i < numStreams; i++)
{
try {
var types = new StreamTypeServiceImpl(typesPerStream, namesPerStream, new bool[numStreams], services.EngineURI, false);
_filters[i] = FilterSpecCompiler.MakeFilterSpec(typesPerStream[i], namesPerStream[i],
Collections.SingletonList(statementSpec.FilterRootNode), null,
tagged, tagged, types,
null, statementContext, Collections.SingletonList(i));
}
catch (Exception ex) {
Log.Warn("Unexpected exception analyzing filter paths: " + ex.Message, ex);
}
}
}
// obtain result set processor
var isIStreamOnly = new bool[namesPerStream.Length];
CompatExtensions.Fill(isIStreamOnly, true);
StreamTypeService typeService = new StreamTypeServiceImpl(typesPerStream, namesPerStream, isIStreamOnly, services.EngineURI, true);
EPStatementStartMethodHelperValidate.ValidateNodes(statementSpec, statementContext, typeService, null);
var resultSetProcessorPrototype = ResultSetProcessorFactoryFactory.GetProcessorPrototype(statementSpec, statementContext, typeService, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, _services.ConfigSnapshot);
_resultSetProcessor = EPStatementStartMethodHelperAssignExpr.GetAssignResultSetProcessor(_agentInstanceContext, resultSetProcessorPrototype);
if (statementSpec.SelectClauseSpec.IsDistinct)
{
if (_resultSetProcessor.ResultEventType is EventTypeSPI)
{
_eventBeanReader = ((EventTypeSPI)_resultSetProcessor.ResultEventType).GetReader();
}
if (_eventBeanReader == null)
{
_eventBeanReader = new EventBeanReaderDefaultImpl(_resultSetProcessor.ResultEventType);
}
}
// plan joins or simple queries
if (numStreams > 1)
{
var streamJoinAnalysisResult = new StreamJoinAnalysisResult(numStreams);
CompatExtensions.Fill(streamJoinAnalysisResult.NamedWindow, true);
for (var i = 0; i < numStreams; i++)
{
var processorInstance = _processors[i].GetProcessorInstance(_agentInstanceContext);
if (_processors[i].IsVirtualDataWindow)
{
streamJoinAnalysisResult.ViewExternal[i] = agentInstanceContext => processorInstance.VirtualDataWindow;
}
var uniqueIndexes = _processors[i].GetUniqueIndexes(processorInstance);
streamJoinAnalysisResult.UniqueKeys[i] = uniqueIndexes;
}
var hasAggregations = !resultSetProcessorPrototype.AggregationServiceFactoryDesc.Expressions.IsEmpty();
_joinSetComposerPrototype = JoinSetComposerPrototypeFactory.MakeComposerPrototype(
null, null,
statementSpec.OuterJoinDescList, statementSpec.FilterRootNode, typesPerStream, namesPerStream,
streamJoinAnalysisResult, queryPlanLogging, statementContext, new HistoricalViewableDesc(numStreams),
_agentInstanceContext, false, hasAggregations, services.TableService, true);
}
// check context partition use
if (statementSpec.OptionalContextName != null)
{
if (numStreams > 1)
{
throw new ExprValidationException("Joins in runtime queries for context partitions are not supported");
}
}
}
public FAFQueryMethodSelectDesc(
StatementSpecCompiled statementSpec,
Compilable compilable,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
Annotations = statementSpec.Annotations;
ContextName = statementSpec.Raw.OptionalContextName;
var queryPlanLogging = services.Configuration.Common.Logging.IsEnableQueryPlan;
if (queryPlanLogging) {
QUERY_PLAN_LOG.Info("Query plans for Fire-and-forget query '" + compilable.ToEPL() + "'");
}
HasTableAccess = statementSpec.TableAccessNodes != null && statementSpec.TableAccessNodes.Count > 0;
foreach (var streamSpec in statementSpec.StreamSpecs) {
HasTableAccess |= streamSpec is TableQueryStreamSpec;
}
HasTableAccess |= StatementLifecycleSvcUtil.IsSubqueryWithTable(
statementSpec.SubselectNodes, services.TableCompileTimeResolver);
IsDistinct = statementSpec.SelectClauseCompiled.IsDistinct;
FAFQueryMethodHelper.ValidateFAFQuery(statementSpec);
var numStreams = statementSpec.StreamSpecs.Length;
var typesPerStream = new EventType[numStreams];
var namesPerStream = new string[numStreams];
var eventTypeNames = new string[numStreams];
Processors = new FireAndForgetProcessorForge[numStreams];
ConsumerFilters = new ExprNode[numStreams];
// check context partition use
if (statementSpec.Raw.OptionalContextName != null) {
if (numStreams > 1) {
throw new ExprValidationException(
"Joins in runtime queries for context partitions are not supported");
}
}
// resolve types and processors
for (var i = 0; i < numStreams; i++) {
var streamSpec = statementSpec.StreamSpecs[i];
Processors[i] = FireAndForgetProcessorForgeFactory.ValidateResolveProcessor(streamSpec);
if (numStreams > 1 && Processors[i].ContextName != null) {
throw new ExprValidationException(
"Joins against named windows that are under context are not supported");
}
var streamName = Processors[i].NamedWindowOrTableName;
if (streamSpec.OptionalStreamName != null) {
streamName = streamSpec.OptionalStreamName;
}
namesPerStream[i] = streamName;
typesPerStream[i] = Processors[i].EventTypeRspInputEvents;
eventTypeNames[i] = typesPerStream[i].Name;
IList<ExprNode> consumerFilterExprs;
if (streamSpec is NamedWindowConsumerStreamSpec) {
var namedSpec = (NamedWindowConsumerStreamSpec) streamSpec;
consumerFilterExprs = namedSpec.FilterExpressions;
}
else {
var tableSpec = (TableQueryStreamSpec) streamSpec;
consumerFilterExprs = tableSpec.FilterExpressions;
}
ConsumerFilters[i] = ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(consumerFilterExprs);
}
// compile filter to optimize access to named window
var optionalStreamsIfAny = OuterJoinAnalyzer.OptionalStreamsIfAny(statementSpec.Raw.OuterJoinDescList);
var types = new StreamTypeServiceImpl(
typesPerStream,
namesPerStream,
new bool[numStreams],
false,
optionalStreamsIfAny);
var excludePlanHint = ExcludePlanHint.GetHint(types.StreamNames, statementRawInfo, services);
QueryGraph = new QueryGraphForge(numStreams, excludePlanHint, false);
if (statementSpec.Raw.WhereClause != null) {
for (var i = 0; i < numStreams; i++) {
try {
var validationContext = new ExprValidationContextBuilder(types, statementRawInfo, services)
.WithAllowBindingConsumption(true)
.WithIsFilterExpression(true)
.Build();
var validated = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.FILTER,
statementSpec.Raw.WhereClause,
validationContext);
FilterExprAnalyzer.Analyze(validated, QueryGraph, false);
}
catch (Exception ex) {
Log.Warn("Unexpected exception analyzing filter paths: " + ex.Message, ex);
}
}
}
// handle subselects
// first we create streams for subselects, if there are any
var @base = new StatementBaseInfo(compilable, statementSpec, null, statementRawInfo, null);
var subqueryNamedWindowConsumers = new List<NamedWindowConsumerStreamSpec>();
SubSelectActivationDesc subSelectActivationDesc = SubSelectHelperActivations.CreateSubSelectActivation(
EmptyList<FilterSpecCompiled>.Instance, subqueryNamedWindowConsumers, @base, services);
IDictionary<ExprSubselectNode, SubSelectActivationPlan> subselectActivation = subSelectActivationDesc.Subselects;
AdditionalForgeables.AddAll(subSelectActivationDesc.AdditionalForgeables);
SubSelectHelperForgePlan subSelectForgePlan = SubSelectHelperForgePlanner.PlanSubSelect(
@base, subselectActivation, namesPerStream, typesPerStream, eventTypeNames, services);
SubselectForges = subSelectForgePlan.Subselects;
AdditionalForgeables.AddAll(subSelectForgePlan.AdditionalForgeables);
// obtain result set processor
var isIStreamOnly = new bool[namesPerStream.Length];
isIStreamOnly.Fill(true);
StreamTypeService typeService = new StreamTypeServiceImpl(
typesPerStream,
namesPerStream,
isIStreamOnly,
true,
optionalStreamsIfAny);
WhereClause = EPStatementStartMethodHelperValidate.ValidateNodes(
statementSpec.Raw,
typeService,
null,
statementRawInfo,
services);
var resultSetSpec = new ResultSetSpec(statementSpec);
ResultSetProcessor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
resultSetSpec,
typeService,
null,
new bool[0],
true,
null,
true,
false,
statementRawInfo,
services);
AdditionalForgeables.AddAll(ResultSetProcessor.AdditionalForgeables);
// plan table access
TableAccessForges = ExprTableEvalHelperPlan.PlanTableAccess(statementSpec.Raw.TableExpressions);
// plan joins or simple queries
if (numStreams > 1) {
var streamJoinAnalysisResult = new StreamJoinAnalysisResultCompileTime(numStreams);
CompatExtensions.Fill(streamJoinAnalysisResult.NamedWindowsPerStream, (NamedWindowMetaData) null);
for (var i = 0; i < numStreams; i++) {
var uniqueIndexes = Processors[i].UniqueIndexes;
streamJoinAnalysisResult.UniqueKeys[i] = uniqueIndexes;
}
var hasAggregations = ResultSetProcessor.ResultSetProcessorType.IsAggregated();
var desc = JoinSetComposerPrototypeForgeFactory.MakeComposerPrototype(
statementSpec,
streamJoinAnalysisResult,
types,
new HistoricalViewableDesc(numStreams),
true,
hasAggregations,
statementRawInfo,
services);
AdditionalForgeables.AddAll(desc.AdditionalForgeables);
Joins = desc.Forge;
}
else {
Joins = null;
}
var multiKeyPlan = MultiKeyPlanner.PlanMultiKeyDistinct(
IsDistinct, ResultSetProcessor.ResultEventType, statementRawInfo, SerdeCompileTimeResolverNonHA.INSTANCE);
AdditionalForgeables.AddAll(multiKeyPlan.MultiKeyForgeables);
DistinctMultiKey = multiKeyPlan.ClassRef;
}
