public StatementAgentInstanceFactoryOnTriggerInfraSelectForge(
ViewableActivatorForge activator,
EventType resultEventType,
IDictionary<ExprSubselectNode, SubSelectFactoryForge> subselects,
IDictionary<ExprTableAccessNode, ExprTableEvalStrategyFactoryForge> tableAccesses,
NamedWindowMetaData namedWindow,
TableMetaData table,
SubordinateWMatchExprQueryPlanForge queryPlanForge,
string resultSetProcessorProviderClassName,
bool insertInto,
bool addToFront,
TableMetaData optionalInsertIntoTable,
bool selectAndDelete,
bool distinct,
MultiKeyClassRef distinctMultiKey)
: base(activator, resultEventType, subselects, tableAccesses, null, namedWindow, table, queryPlanForge)
{
this.resultSetProcessorProviderClassName = resultSetProcessorProviderClassName;
this.insertInto = insertInto;
this.addToFront = addToFront;
this.optionalInsertIntoTable = optionalInsertIntoTable;
this.selectAndDelete = selectAndDelete;
this.distinct = distinct;
this.distinctMultiKey = distinctMultiKey;
}
private OnTriggerActivatorDesc ActivatorNamedWindow(
NamedWindowConsumerStreamSpec namedSpec,
StatementCompileTimeServices services)
{
NamedWindowMetaData namedWindow = namedSpec.NamedWindow;
string triggerEventTypeName = namedSpec.NamedWindow.EventType.Name;
var typesFilterValidation = new StreamTypeServiceImpl(
namedWindow.EventType,
namedSpec.OptionalStreamName,
false);
var filterSingle =
ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(namedSpec.FilterExpressions);
QueryGraphForge filterQueryGraph = EPLValidationUtil.ValidateFilterGetQueryGraphSafe(
filterSingle,
typesFilterValidation,
@base.StatementRawInfo,
services);
var activator = new ViewableActivatorNamedWindowForge(
namedSpec,
namedWindow,
filterSingle,
filterQueryGraph,
false,
namedSpec.OptPropertyEvaluator);
var activatorResultEventType = namedWindow.EventType;
if (namedSpec.OptPropertyEvaluator != null) {
activatorResultEventType = namedSpec.OptPropertyEvaluator.FragmentEventType;
}
return new OnTriggerActivatorDesc(activator, triggerEventTypeName, activatorResultEventType);
}
public SubSelectStrategyFactoryLocalViewPreloadedForge(
IList <ViewFactoryForge> viewForges,
ViewResourceDelegateDesc viewResourceDelegateDesc,
Pair <EventTableFactoryFactoryForge, SubordTableLookupStrategyFactoryForge> lookupStrategy,
ExprNode filterExprNode,
bool correlatedSubquery,
AggregationServiceForgeDesc aggregationServiceForgeDesc,
int subqueryNumber,
ExprNode[] groupKeys,
NamedWindowMetaData namedWindow,
ExprNode namedWindowFilterExpr,
QueryGraphForge namedWindowFilterQueryGraph,
MultiKeyClassRef groupByMultiKeyClasses)
{
_viewForges = viewForges;
_viewResourceDelegateDesc = viewResourceDelegateDesc;
_lookupStrategy = lookupStrategy;
_filterExprNode = filterExprNode;
_correlatedSubquery = correlatedSubquery;
_aggregationServiceForgeDesc = aggregationServiceForgeDesc;
_subqueryNumber = subqueryNumber;
_groupKeys = groupKeys;
_namedWindow = namedWindow;
_namedWindowFilterExpr = namedWindowFilterExpr;
_namedWindowFilterQueryGraph = namedWindowFilterQueryGraph;
_groupByMultiKeyClasses = groupByMultiKeyClasses;
}
public void RegisterIndex(
IndexCompileTimeKey indexKey,
IndexDetail indexDetail)
{
EventTableIndexMetadata indexMetadata = null;
if (indexKey.IsNamedWindow) {
NamedWindowMetaData localNamedWindow = moduleNamedWindows.Get(indexKey.InfraName);
if (localNamedWindow != null) {
indexMetadata = localNamedWindow.IndexMetadata;
}
else {
if (indexKey.Visibility == NameAccessModifier.PUBLIC) {
NamedWindowMetaData pathNamedWindow = pathNamedWindows.GetWithModule(
indexKey.InfraName,
indexKey.InfraModuleName);
if (pathNamedWindow != null) {
indexMetadata = pathNamedWindow.IndexMetadata;
}
}
}
if (indexMetadata == null) {
throw new EPException("Failed to find named window '" + indexKey.InfraName + "'");
}
}
else {
TableMetaData localTable = moduleTables.Get(indexKey.InfraName);
if (localTable != null) {
indexMetadata = localTable.IndexMetadata;
}
else {
if (indexKey.Visibility == NameAccessModifier.PUBLIC) {
TableMetaData pathTable = pathTables.GetWithModule(
indexKey.InfraName,
indexKey.InfraModuleName);
if (pathTable != null) {
indexMetadata = pathTable.IndexMetadata;
}
}
}
if (indexMetadata == null) {
throw new EPException("Failed to find table '" + indexKey.InfraName + "'");
}
}
try {
indexMetadata.AddIndexExplicit(
false,
indexDetail.IndexMultiKey,
indexKey.IndexName,
indexKey.InfraModuleName,
indexDetail.QueryPlanIndexItem,
"");
}
catch (ExprValidationException ex) {
throw new EPException(ex.Message, ex);
}
}
public static FireAndForgetProcessorForge ValidateResolveProcessor(StreamSpecCompiled streamSpec)
{
if (streamSpec is NamedWindowConsumerStreamSpec) {
NamedWindowMetaData nwdetail = ((NamedWindowConsumerStreamSpec) streamSpec).NamedWindow;
return new FireAndForgetProcessorNamedWindowForge(nwdetail);
}
TableQueryStreamSpec tableSpec = (TableQueryStreamSpec) streamSpec;
return new FireAndForgetProcessorTableForge(tableSpec.Table);
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="numStreams">number of streams</param>
public StreamJoinAnalysisResultCompileTime(int numStreams)
{
NumStreams = numStreams;
IsPureSelfJoin = false;
UnidirectionalInd = new bool[numStreams];
_unidirectionalNonDriving = new bool[numStreams];
HasChildViews = new bool[numStreams];
NamedWindowsPerStream = new NamedWindowMetaData[numStreams];
UniqueKeys = new string[numStreams][][];
TablesPerStream = new TableMetaData[numStreams];
}
public static CodegenExpression MakeResolveNamedWindow(
NamedWindowMetaData namedWindow,
CodegenExpression initSvc)
{
return StaticMethod(
typeof(NamedWindowDeployTimeResolver),
"ResolveNamedWindow",
Constant(namedWindow.EventType.Name),
Constant(namedWindow.EventType.Metadata.AccessModifier),
Constant(namedWindow.NamedWindowModuleName),
initSvc);
}
public NamedWindowImpl(
NamedWindowMetaData metadata,
EPStatementInitServices services)
{
rootView = new NamedWindowRootView(metadata);
eventTableIndexMetadataRepo = metadata.IndexMetadata;
tailView = services.NamedWindowFactoryService.CreateNamedWindowTailView(
metadata.EventType,
metadata.IsChildBatching,
services,
metadata.ContextName);
}
public void AddNamedWindow(
string windowName,
NamedWindowMetaData metadata,
EPStatementInitServices services)
{
NamedWindowDeployment deployment = deployments.Get(services.DeploymentId);
if (deployment == null) {
deployment = new NamedWindowDeployment();
deployments.Put(services.DeploymentId, deployment);
}
deployment.Add(windowName, metadata, services);
}
public void Add(
string windowName,
NamedWindowMetaData metadata,
EPStatementInitServices services)
{
NamedWindow existing = namedWindows.Get(windowName);
if (existing != null) {
throw new IllegalStateException("Named window processor already found for name '" + windowName + "'");
}
NamedWindow namedWindow = services.NamedWindowFactoryService.CreateNamedWindow(metadata, services);
namedWindows.Put(windowName, namedWindow);
}
public NamedWindowConsumerStreamSpec(
NamedWindowMetaData namedWindow,
string optionalAsName,
ViewSpec[] viewSpecs,
IList<ExprNode> filterExpressions,
StreamSpecOptions streamSpecOptions,
PropertyEvaluatorForge optPropertyEvaluator)
: base(optionalAsName, viewSpecs, streamSpecOptions)
{
NamedWindow = namedWindow;
FilterExpressions = filterExpressions;
OptPropertyEvaluator = optPropertyEvaluator;
}
public void NewNamedWindow(NamedWindowMetaData detail)
{
var eventType = detail.EventType;
if (!eventType.Metadata.AccessModifier.IsModuleProvidedAccessModifier()) {
throw new IllegalStateException("Invalid visibility for named window");
}
var namedWindowName = detail.EventType.Name;
var existing = NamedWindows.Get(namedWindowName);
if (existing != null) {
throw new IllegalStateException("Duplicate named window definition encountered");
}
NamedWindows.Put(namedWindowName, detail);
}
public ViewableActivatorNamedWindowForge(
NamedWindowConsumerStreamSpec spec,
NamedWindowMetaData namedWindow,
ExprNode filterEvaluator,
QueryGraphForge filterQueryGraph,
bool subquery,
PropertyEvaluatorForge optPropertyEvaluator)
{
this.spec = spec;
this.namedWindow = namedWindow;
this.filterEvaluator = filterEvaluator;
this.filterQueryGraph = filterQueryGraph;
this.subquery = subquery;
this.optPropertyEvaluator = optPropertyEvaluator;
}
private static EventTableIndexMetadata GetIndexMetadata(
ModuleIndexMeta objectName,
string moduleName,
EPServicesPath paths)
{
if (objectName.IsNamedWindow)
{
NamedWindowMetaData metaData = paths.NamedWindowPathRegistry.GetWithModule(objectName.InfraName, moduleName);
return(metaData?.IndexMetadata);
}
else
{
TableMetaData metaData = paths.TablePathRegistry.GetWithModule(objectName.InfraName, moduleName);
return(metaData?.IndexMetadata);
}
}
public StatementAgentInstanceFactoryCreateIndexForge(
EventType eventType,
string indexName,
string indexModuleName,
QueryPlanIndexItemForge explicitIndexDesc,
IndexMultiKey imk,
NamedWindowMetaData namedWindow,
TableMetaData table)
{
this.eventType = eventType;
this.indexName = indexName;
this.indexModuleName = indexModuleName;
this.explicitIndexDesc = explicitIndexDesc;
this.imk = imk;
this.namedWindow = namedWindow;
this.table = table;
}
public StatementAgentInstanceFactoryCreateNWForge(
ViewableActivatorFilterForge activator,
string namedWindowName,
IList<ViewFactoryForge> views,
NamedWindowMetaData insertFromNamedWindow,
ExprNode insertFromFilter,
EventType asEventType,
string resultSetProcessorProviderClassName)
{
this.activator = activator;
this.namedWindowName = namedWindowName;
this.views = views;
this.insertFromNamedWindow = insertFromNamedWindow;
this.insertFromFilter = insertFromFilter;
this.asEventType = asEventType;
this.resultSetProcessorProviderClassName = resultSetProcessorProviderClassName;
}
public StatementAgentInstanceFactoryOnTriggerInfraBaseForge(
ViewableActivatorForge activator,
EventType resultEventType,
IDictionary<ExprSubselectNode, SubSelectFactoryForge> subselects,
IDictionary<ExprTableAccessNode, ExprTableEvalStrategyFactoryForge> tableAccesses,
string nonSelectRSPProviderClassName,
NamedWindowMetaData namedWindow,
TableMetaData table,
SubordinateWMatchExprQueryPlanForge queryPlanForge)
: base(activator, resultEventType, subselects, tableAccesses)
{
this.nonSelectRSPProviderClassName = nonSelectRSPProviderClassName;
this.namedWindow = namedWindow;
this.table = table;
this.queryPlanForge = queryPlanForge;
}
public void SetNamedWindowsPerStream(
int streamNum,
NamedWindowMetaData metadata)
{
NamedWindowsPerStream[streamNum] = metadata;
}
public SubSelectStrategyFactoryIndexShareForge(
int subqueryNumber,
SubSelectActivationPlan subselectActivation,
EventType[] outerEventTypesSelect,
NamedWindowMetaData namedWindow,
TableMetaData table,
bool fullTableScan,
IndexHint indexHint,
SubordPropPlan joinedPropPlan,
ExprForge filterExprEval,
ExprNode[] groupKeys,
AggregationServiceForgeDesc aggregationServiceForgeDesc,
StatementBaseInfo statement,
StatementCompileTimeServices services)
{
_subqueryNumber = subqueryNumber;
_namedWindow = namedWindow;
_table = table;
_filterExprEval = filterExprEval;
_groupKeys = groupKeys;
_aggregationServiceForgeDesc = aggregationServiceForgeDesc;
bool queryPlanLogging = services.Configuration.Common.Logging.IsEnableQueryPlan;
// We only use existing indexes in all cases. This means "create index" is required.
SubordinateQueryPlan plan;
if (table != null)
{
plan = SubordinateQueryPlanner.PlanSubquery(
outerEventTypesSelect,
joinedPropPlan,
false,
fullTableScan,
indexHint,
true,
subqueryNumber,
false,
table.IndexMetadata,
table.UniquenessAsSet,
true,
table.InternalEventType,
statement.StatementRawInfo,
services);
}
else
{
plan = SubordinateQueryPlanner.PlanSubquery(
outerEventTypesSelect,
joinedPropPlan,
false,
fullTableScan,
indexHint,
true,
subqueryNumber,
namedWindow.IsVirtualDataWindow,
namedWindow.IndexMetadata,
namedWindow.UniquenessAsSet,
true,
namedWindow.EventType,
statement.StatementRawInfo,
services);
}
_queryPlan = plan == null ? null : plan.Forge;
if (plan != null)
{
_additionalForgeables.AddAll(plan.AdditionalForgeables);
}
if (_queryPlan != null && _queryPlan.IndexDescs != null)
{
for (int i = 0; i < _queryPlan.IndexDescs.Length; i++)
{
SubordinateQueryIndexDescForge index = _queryPlan.IndexDescs[i];
if (table != null)
{
if (table.TableVisibility == NameAccessModifier.PUBLIC)
{
services.ModuleDependenciesCompileTime.AddPathIndex(
false,
table.TableName,
table.TableModuleName,
index.IndexName,
index.IndexModuleName,
services.NamedWindowCompileTimeRegistry,
services.TableCompileTimeRegistry);
}
}
else
{
if (namedWindow.EventType.Metadata.AccessModifier == NameAccessModifier.PUBLIC)
{
services.ModuleDependenciesCompileTime.AddPathIndex(
true,
namedWindow.EventType.Name,
namedWindow.NamedWindowModuleName,
index.IndexName,
index.IndexModuleName,
services.NamedWindowCompileTimeRegistry,
services.TableCompileTimeRegistry);
}
}
}
}
SubordinateQueryPlannerUtil.QueryPlanLogOnSubq(
queryPlanLogging,
QUERY_PLAN_LOG,
_queryPlan,
subqueryNumber,
statement.StatementRawInfo.Annotations,
services.ImportServiceCompileTime);
if (groupKeys == null || groupKeys.Length == 0)
{
_groupByMultiKey = null;
}
else
{
MultiKeyPlan mkplan = MultiKeyPlanner.PlanMultiKey(groupKeys, false, statement.StatementRawInfo, services.SerdeResolver);
_additionalForgeables.AddAll(mkplan.MultiKeyForgeables);
_groupByMultiKey = mkplan.ClassRef;
}
}
public FireAndForgetProcessorNamedWindowForge(NamedWindowMetaData namedWindow)
{
this.namedWindow = namedWindow;
}
public static void ValidateStatementKeyAndHash(
IEnumerable<Supplier<EventType>> typeProvider,
string contextName,
StatementSpecCompiled spec,
StatementCompileTimeServices compileTimeServices)
{
StatementSpecCompiledAnalyzerResult streamAnalysis = StatementSpecCompiledAnalyzer.AnalyzeFilters(spec);
IList<FilterSpecCompiled> filters = streamAnalysis.Filters;
var isCreateWindow = spec.Raw.CreateWindowDesc != null;
// if no create-window: at least one of the filters must match one of the filters specified by the context
if (!isCreateWindow) {
foreach (var filter in filters) {
foreach (var item in typeProvider) {
EventType itemEventType = item.Invoke();
var stmtFilterType = filter.FilterForEventType;
if (ReferenceEquals(stmtFilterType, itemEventType)) {
return;
}
if (EventTypeUtility.IsTypeOrSubTypeOf(stmtFilterType, itemEventType)) {
return;
}
NamedWindowMetaData namedWindow =
compileTimeServices.NamedWindowCompileTimeResolver.Resolve(stmtFilterType.Name);
string namedWindowContextName = namedWindow?.ContextName;
if (namedWindowContextName != null && namedWindowContextName.Equals(contextName)) {
return;
}
}
}
if (!filters.IsEmpty()) {
throw new ExprValidationException(
GetTypeValidationMessage(contextName, filters[0].FilterForEventType.Name));
}
return;
}
// validate create-window with column definition: not allowed, requires typed
if (spec.Raw.CreateWindowDesc.Columns != null &&
spec.Raw.CreateWindowDesc.Columns.Count > 0) {
throw new ExprValidationException(
"Segmented context '" +
contextName +
"' requires that named windows are associated to an existing event type and that the event type is listed among the partitions defined by the create-context statement");
}
// validate create-window declared type
var declaredAsName = spec.Raw.CreateWindowDesc.AsEventTypeName;
if (declaredAsName != null) {
foreach (var item in typeProvider) {
EventType itemEventType = item.Invoke();
if (itemEventType.Name.Equals(declaredAsName)) {
return;
}
}
throw new ExprValidationException(GetTypeValidationMessage(contextName, declaredAsName));
}
}
public static SubSelectActivationDesc CreateSubSelectActivation(
IList <FilterSpecCompiled> filterSpecCompileds,
IList <NamedWindowConsumerStreamSpec> namedWindowConsumers,
StatementBaseInfo statement,
StatementCompileTimeServices services)
{
IDictionary <ExprSubselectNode, SubSelectActivationPlan> result = new LinkedHashMap <ExprSubselectNode, SubSelectActivationPlan>();
IList <StmtClassForgeableFactory> additionalForgeables = new List <StmtClassForgeableFactory>();
// Process all subselect expression nodes
foreach (ExprSubselectNode subselect in statement.StatementSpec.SubselectNodes)
{
StatementSpecCompiled statementSpec = subselect.StatementSpecCompiled;
StreamSpecCompiled streamSpec = statementSpec.StreamSpecs[0];
int subqueryNumber = subselect.SubselectNumber;
if (subqueryNumber == -1)
{
throw new IllegalStateException("Unexpected subquery");
}
ViewFactoryForgeArgs args = new ViewFactoryForgeArgs(-1, true, subqueryNumber, streamSpec.Options, null, statement.StatementRawInfo, services);
if (streamSpec is FilterStreamSpecCompiled)
{
if (services.IsFireAndForget)
{
throw new ExprValidationException("Fire-and-forget queries only allow subqueries against named windows and tables");
}
FilterStreamSpecCompiled filterStreamSpec = (FilterStreamSpecCompiled)statementSpec.StreamSpecs[0];
// Register filter, create view factories
ViewableActivatorForge activatorDeactivator = new ViewableActivatorFilterForge(
filterStreamSpec.FilterSpecCompiled,
false,
null,
true,
subqueryNumber);
ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(
streamSpec.ViewSpecs,
args,
filterStreamSpec.FilterSpecCompiled.ResultEventType);
IList <ViewFactoryForge> forges = viewForgeDesc.Forges;
additionalForgeables.AddAll(viewForgeDesc.MultikeyForges);
EventType eventType = forges.IsEmpty() ? filterStreamSpec.FilterSpecCompiled.ResultEventType : forges[forges.Count - 1].EventType;
subselect.RawEventType = eventType;
filterSpecCompileds.Add(filterStreamSpec.FilterSpecCompiled);
// Add lookup to list, for later starts
result.Put(
subselect,
new SubSelectActivationPlan(filterStreamSpec.FilterSpecCompiled.ResultEventType, forges, activatorDeactivator, streamSpec));
}
else if (streamSpec is TableQueryStreamSpec)
{
TableQueryStreamSpec table = (TableQueryStreamSpec)streamSpec;
ExprNode filter = ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(table.FilterExpressions);
ViewableActivatorForge viewableActivator = new ViewableActivatorTableForge(table.Table, filter);
result.Put(
subselect,
new SubSelectActivationPlan(table.Table.InternalEventType, EmptyList <ViewFactoryForge> .Instance, viewableActivator, streamSpec));
subselect.RawEventType = table.Table.InternalEventType;
}
else
{
NamedWindowConsumerStreamSpec namedSpec = (NamedWindowConsumerStreamSpec)statementSpec.StreamSpecs[0];
namedWindowConsumers.Add(namedSpec);
NamedWindowMetaData nwinfo = namedSpec.NamedWindow;
EventType namedWindowType = nwinfo.EventType;
if (namedSpec.OptPropertyEvaluator != null)
{
namedWindowType = namedSpec.OptPropertyEvaluator.FragmentEventType;
}
// if named-window index sharing is disabled (the default) or filter expressions are provided then consume the insert-remove stream
bool disableIndexShare = HintEnum.DISABLE_WINDOW_SUBQUERY_INDEXSHARE.GetHint(statement.StatementRawInfo.Annotations) != null;
bool processorDisableIndexShare = !namedSpec.NamedWindow.IsEnableIndexShare;
if (disableIndexShare && namedSpec.NamedWindow.IsVirtualDataWindow)
{
disableIndexShare = false;
}
if ((!namedSpec.FilterExpressions.IsEmpty() || processorDisableIndexShare || disableIndexShare) && (!services.IsFireAndForget))
{
ExprNode filterEvaluator = null;
if (!namedSpec.FilterExpressions.IsEmpty())
{
filterEvaluator = ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(namedSpec.FilterExpressions);
}
ViewableActivatorForge activatorNamedWindow = new ViewableActivatorNamedWindowForge(
namedSpec,
nwinfo,
filterEvaluator,
null,
true,
namedSpec.OptPropertyEvaluator);
ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(streamSpec.ViewSpecs, args, namedWindowType);
IList <ViewFactoryForge> forges = viewForgeDesc.Forges;
additionalForgeables.AddAll(viewForgeDesc.MultikeyForges);
subselect.RawEventType = forges.IsEmpty() ? namedWindowType : forges[forges.Count - 1].EventType;
result.Put(subselect, new SubSelectActivationPlan(namedWindowType, forges, activatorNamedWindow, streamSpec));
}
else
{
// else if there are no named window stream filter expressions and index sharing is enabled
ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(streamSpec.ViewSpecs, args, namedWindowType);
IList <ViewFactoryForge> forges = viewForgeDesc.Forges;
additionalForgeables.AddAll(viewForgeDesc.MultikeyForges);
subselect.RawEventType = namedWindowType;
ViewableActivatorForge activatorNamedWindow = new ViewableActivatorSubselectNoneForge(namedWindowType);
result.Put(subselect, new SubSelectActivationPlan(namedWindowType, forges, activatorNamedWindow, streamSpec));
}
}
}
return(new SubSelectActivationDesc(result, additionalForgeables));
}
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);
}
public NamedWindowRootView(NamedWindowMetaData vo)
{
namedWindowMetaData = vo;
}
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 NamedWindow CreateNamedWindow(
NamedWindowMetaData metadata,
EPStatementInitServices services)
{
return new NamedWindowImpl(metadata, services);
}
