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 ResultSetProcessorDesc(
ResultSetProcessorFactoryForge resultSetProcessorFactoryForge,
ResultSetProcessorType resultSetProcessorType,
SelectExprProcessorForge[] selectExprProcessorForges,
bool join,
bool hasOutputLimit,
ResultSetProcessorOutputConditionType? outputConditionType,
bool hasOutputLimitSnapshot,
EventType resultEventType,
bool rollup,
AggregationServiceForgeDesc aggregationServiceForgeDesc,
OrderByProcessorFactoryForge orderByProcessorFactoryForge,
SelectSubscriberDescriptor selectSubscriberDescriptor,
IList<StmtClassForgeableFactory> additionalForgeables)
{
ResultSetProcessorFactoryForge = resultSetProcessorFactoryForge;
ResultSetProcessorType = resultSetProcessorType;
SelectExprProcessorForges = selectExprProcessorForges;
IsJoin = join;
HasOutputLimit = hasOutputLimit;
OutputConditionType = outputConditionType;
HasOutputLimitSnapshot = hasOutputLimitSnapshot;
ResultEventType = resultEventType;
IsRollup = rollup;
AggregationServiceForgeDesc = aggregationServiceForgeDesc;
OrderByProcessorFactoryForge = orderByProcessorFactoryForge;
SelectSubscriberDescriptor = selectSubscriberDescriptor;
AdditionalForgeables = additionalForgeables;
}
internal static CodegenExpression MakeAggregationService(
int subqueryNumber,
AggregationServiceForgeDesc aggregationServiceForgeDesc,
CodegenClassScope classScope,
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols)
{
if (aggregationServiceForgeDesc == null)
{
return(ConstantNull());
}
AggregationClassNames aggregationClassNames =
new AggregationClassNames(CodegenNamespaceScopeNames.ClassPostfixAggregationForSubquery(subqueryNumber));
AggregationServiceFactoryMakeResult aggResult = AggregationServiceFactoryCompiler.MakeInnerClassesAndInit(
false,
aggregationServiceForgeDesc.AggregationServiceFactoryForge,
parent,
classScope,
classScope.OutermostClassName,
aggregationClassNames);
classScope.AddInnerClasses(aggResult.InnerClasses);
return(LocalMethod(aggResult.InitMethod, symbols.GetAddInitSvc(parent)));
}
private static AggregationServiceForgeDesc[] PlanAggregations(
IList<ExprAggregateNode> measureAggregateExprNodes,
StreamTypeService compositeTypeServiceMeasure,
string[] allStreamNames,
EventType[] allTypes,
IOrderedDictionary<int, string> streamVariables,
ISet<string> variablesMultiple,
StatementBaseInfo @base,
StatementCompileTimeServices services)
{
IDictionary<int, IList<ExprAggregateNode>> measureExprAggNodesPerStream =
new Dictionary<int, IList<ExprAggregateNode>>();
foreach (var aggregateNode in measureAggregateExprNodes) {
// validate node and params
var count = 0;
var visitor = new ExprNodeIdentifierVisitor(true);
var isIStreamOnly = new bool[allStreamNames.Length];
var typeServiceAggregateMeasure = new StreamTypeServiceImpl(
allTypes,
allStreamNames,
isIStreamOnly,
false,
true);
var validationContext =
new ExprValidationContextBuilder(typeServiceAggregateMeasure, @base.StatementRawInfo, services)
.WithAllowBindingConsumption(true)
.Build();
aggregateNode.ValidatePositionals(validationContext);
if (aggregateNode.OptionalLocalGroupBy != null) {
throw new ExprValidationException(
"Match-recognize does not allow aggregation functions to specify a group-by");
}
foreach (var child in aggregateNode.ChildNodes) {
var validated = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.MATCHRECOGMEASURE,
child,
validationContext);
validated.Accept(visitor);
aggregateNode.SetChildNode(count++, new ExprNodeValidated(validated));
}
// verify properties used within the aggregation
ISet<int> aggregatedStreams = new HashSet<int>();
foreach (var pair in visitor.ExprProperties) {
aggregatedStreams.Add(pair.First);
}
int? multipleVarStream = null;
foreach (var streamNumAggregated in aggregatedStreams) {
var variable = streamVariables.Get(streamNumAggregated);
if (variablesMultiple.Contains(variable)) {
if (multipleVarStream == null) {
multipleVarStream = streamNumAggregated;
continue;
}
throw new ExprValidationException(
"Aggregation functions in the measure-clause must only refer to properties of exactly one group variable returning multiple events");
}
}
if (multipleVarStream == null) {
throw new ExprValidationException(
"Aggregation functions in the measure-clause must refer to one or more properties of exactly one group variable returning multiple events");
}
var aggNodesForStream = measureExprAggNodesPerStream.Get(multipleVarStream.Value);
if (aggNodesForStream == null) {
aggNodesForStream = new List<ExprAggregateNode>();
measureExprAggNodesPerStream.Put(multipleVarStream.Value, aggNodesForStream);
}
aggNodesForStream.Add(aggregateNode);
}
// validate aggregation itself
foreach (var entry in measureExprAggNodesPerStream) {
foreach (var aggregateNode in entry.Value) {
var validationContext = new ExprValidationContextBuilder(
compositeTypeServiceMeasure,
@base.StatementRawInfo,
services)
.WithAllowBindingConsumption(true)
.WithMemberName(new ExprValidationMemberNameQualifiedRowRecogAgg(entry.Key))
.Build();
aggregateNode.Validate(validationContext);
}
}
// get aggregation service per variable
var aggServices = new AggregationServiceForgeDesc[allStreamNames.Length];
var declareds = Arrays.AsList(@base.StatementSpec.DeclaredExpressions);
foreach (var entry in measureExprAggNodesPerStream) {
EventType[] typesPerStream = {allTypes[entry.Key]};
AggregationServiceForgeDesc desc = AggregationServiceFactoryFactory.GetService(
entry.Value,
EmptyDictionary<ExprNode, string>.Instance,
declareds,
new ExprNode[0],
null,
EmptyList<ExprAggregateNode>.Instance,
EmptyList<ExprAggregateNode>.Instance,
EmptyList<ExprAggregateNodeGroupKey>.Instance,
false,
@base.StatementRawInfo.Annotations,
services.VariableCompileTimeResolver,
true,
null,
null,
typesPerStream,
null,
@base.ContextName,
null,
services.TableCompileTimeResolver,
false,
true,
false,
services.ImportServiceCompileTime,
@base.StatementRawInfo,
services.SerdeResolver);
aggServices[entry.Key] = desc;
}
return aggServices;
}
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;
}
}
