private AggregationMethodFactory ValidateAggregationInternal( ExprValidationContext validationContext, TableMetadataColumnAggregation optionalBinding) { ExprAggMultiFunctionSortedMinMaxByNodeFactory factory; // handle table-access expression (state provided, accessor needed) if (optionalBinding != null) { factory = HandleTableAccess(optionalBinding); } else if (validationContext.ExprEvaluatorContext.StatementType == StatementType.CREATE_TABLE) { // handle create-table statements (state creator and default accessor, limited to certain options) factory = HandleCreateTable(validationContext); } else if (validationContext.IntoTableName != null) { // handle into-table (state provided, accessor and agent needed, validation done by factory) factory = HandleIntoTable(validationContext); } else { // handle standalone factory = HandleNonTable(validationContext); } _containedType = factory.ContainedEventType; return(factory); }
private LinearAggregationFactoryDesc HandleTableAccessWindow( ExprNode[] childNodes, AggregationStateType stateType, ExprValidationContext validationContext, TableMetadataColumnAggregation tableAccess) { var original = (ExprAggMultiFunctionLinearAccessNodeFactoryAccess) tableAccess.Factory; if (childNodes.Length == 0 || childNodes.Length == 1 && childNodes[0] is ExprWildcard) { var componentType = original.ContainedEventType.UnderlyingType; var accessor = new AggregationAccessorWindowNoEval(componentType); var factory = new ExprAggMultiFunctionLinearAccessNodeFactoryAccess(this, accessor, TypeHelper.GetArrayType(componentType), original.ContainedEventType, null, null, null); return new LinearAggregationFactoryDesc(factory, factory.ContainedEventType, null); } if (childNodes.Length == 1) { // Expressions apply to events held, thereby validate in terms of event value expressions var paramNode = childNodes[0]; var streams = TableServiceUtil.StreamTypeFromTableColumn(tableAccess, validationContext.StreamTypeService.EngineURIQualifier); var localValidationContext = new ExprValidationContext(streams, validationContext); paramNode = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.AGGPARAM, paramNode, localValidationContext); var paramNodeEval = paramNode.ExprEvaluator; var factory = new ExprAggMultiFunctionLinearAccessNodeFactoryAccess(this, new AggregationAccessorWindowWEval(0, paramNodeEval, paramNodeEval.ReturnType), TypeHelper.GetArrayType(paramNodeEval.ReturnType), original.ContainedEventType, null, null, null); return new LinearAggregationFactoryDesc(factory, null, paramNodeEval.ReturnType); } throw new ExprValidationException("Invalid number of parameters"); }
private AggregationMethodFactory ValidateAggregationInternal( ExprValidationContext validationContext, TableMetadataColumnAggregation optionalBinding) { LinearAggregationFactoryDesc desc; var positionalParams = PositionalParams; // handle table-access expression (state provided, accessor needed) if (optionalBinding != null) { desc = HandleTableAccess(positionalParams, _stateType, validationContext, optionalBinding); } else if (validationContext.ExprEvaluatorContext.StatementType == StatementType.CREATE_TABLE) { // handle create-table statements (state creator and default accessor, limited to certain options) desc = HandleCreateTable(positionalParams, _stateType, validationContext); } else if (validationContext.IntoTableName != null) { // handle into-table (state provided, accessor and agent needed, validation done by factory) desc = HandleIntoTable(positionalParams, _stateType, validationContext); } else { // handle standalone desc = HandleNonIntoTable(positionalParams, _stateType, validationContext); } _containedType = desc.EnumerationEventType; _scalarCollectionComponentType = desc.ScalarCollectionType; return(desc.Factory); }
protected internal static object[] EvalTypable( ObjectArrayBackedEventBean @event, AggregationRow row, IDictionary<string, TableMetadataColumn> items, EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext exprEvaluatorContext) { object[] values = new object[items.Count]; int count = 0; foreach (KeyValuePair<string, TableMetadataColumn> entry in items) { if (entry.Value is TableMetadataColumnPlain) { TableMetadataColumnPlain plain = (TableMetadataColumnPlain) entry.Value; values[count] = @event.Properties[plain.IndexPlain]; } else { TableMetadataColumnAggregation aggcol = (TableMetadataColumnAggregation) entry.Value; values[count] = row.GetValue(aggcol.Column, eventsPerStream, isNewData, exprEvaluatorContext); } count++; } return values; }
public AggregationTableReadDesc ValidateAggregationTableRead( ExprValidationContext context, TableMetadataColumnAggregation tableAccessColumn, TableMetaData table) { if (AggType == CountMinSketchAggType.STATE || AggType == CountMinSketchAggType.ADD) { throw new ExprValidationException(MessagePrefix + "cannot not be used for table access"); } if (!(tableAccessColumn.AggregationPortableValidation is AggregationPortableValidationCountMinSketch)) { throw new ExprValidationException(MessagePrefix + "can only be used with count-min-sketch"); } AggregationTableAccessAggReaderForge forge; if (AggType == CountMinSketchAggType.FREQ) { if (positionalParams.Length == 0 || positionalParams.Length > 1) { throw new ExprValidationException(MessagePrefix + "requires a single parameter expression"); } ExprNodeUtilityValidate.GetValidatedSubtree(ExprNodeOrigin.AGGPARAM, ChildNodes, context); var frequencyEval = ChildNodes[0]; forge = new AgregationTAAReaderCountMinSketchFreqForge(frequencyEval); } else { if (positionalParams.Length != 0) { throw new ExprValidationException(MessagePrefix + "requires a no parameter expressions"); } forge = new AgregationTAAReaderCountMinSketchTopKForge(); } return new AggregationTableReadDesc(forge, null, null, null); }
private static void ValidateIntoTableCompatible( string tableName, string columnName, TableMetadataColumnAggregation columnMetadata, AggregationServiceAggExpressionDesc aggDesc) { var factoryProvided = aggDesc.Factory.AggregationPortableValidation; var factoryRequired = columnMetadata.AggregationPortableValidation; try { factoryRequired.ValidateIntoTableCompatible( columnMetadata.AggregationExpression, factoryProvided, ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(aggDesc.AggregationNode), aggDesc.Factory); } catch (ExprValidationException ex) { var text = GetMessage( tableName, columnName, columnMetadata.AggregationExpression, aggDesc.Factory.AggregationExpression); throw new ExprValidationException(text + ": " + ex.Message, ex); } }
public ExprTableIdentNodeSubpropAccessor(int streamNum, string optionalStreamName, TableMetadataColumnAggregation tableAccessColumn, ExprNode aggregateAccessMultiValueNode) { _streamNum = streamNum; _optionalStreamName = optionalStreamName; _tableAccessColumn = tableAccessColumn; _aggregateAccessMultiValueNode = aggregateAccessMultiValueNode; }
private LinearAggregationFactoryDesc HandleTableAccess( ExprNode[] childNodes, AggregationStateType stateType, ExprValidationContext validationContext, TableMetadataColumnAggregation tableAccess) { if (stateType == AggregationStateType.FIRST || stateType == AggregationStateType.LAST) return HandleTableAccessFirstLast(childNodes, stateType, validationContext, tableAccess); if (stateType == AggregationStateType.WINDOW) return HandleTableAccessWindow(childNodes, stateType, validationContext, tableAccess); throw new IllegalStateException("Unrecognized type " + stateType); }
public ExprDotNodeAggregationMethodForgeTableReset( ExprDotNodeImpl parent, string aggregationMethodName, ExprNode[] parameters, AggregationPortableValidation validation, ExprTableIdentNode identNode, TableMetadataColumnAggregation column) : base(parent, aggregationMethodName, parameters, validation) { this.identNode = identNode; this.column = column; }
public ExprDotNodeAggregationMethodForgeTableAccess( ExprDotNodeImpl parent, string aggregationMethodName, ExprNode[] parameters, AggregationPortableValidation validation, ExprTableAccessNodeSubprop subprop, TableMetadataColumnAggregation column) : base(parent, aggregationMethodName, parameters, validation) { this.subprop = subprop; this.column = column; }
private static void ValidateIntoTableCompatible( string tableName, string columnName, TableMetadataColumnAggregation columnMetadata, AggregationServiceAggExpressionDesc aggDesc) { var factoryProvided = aggDesc.Factory; var factoryRequired = columnMetadata.Factory; try { factoryRequired.ValidateIntoTableCompatible(factoryProvided); } catch (ExprValidationException ex) { var text = GetMessage(tableName, columnName, factoryRequired.AggregationExpression, factoryProvided.AggregationExpression); throw new ExprValidationException(text + ": " + ex.Message, ex); } }
public static ExprEvaluator GetTableAccessEvalStrategy( ExprNode exprNode, string tableName, int streamNum, TableMetadataColumnAggregation agg) { if (!agg.Factory.IsAccessAggregation) { return(new ExprTableExprEvaluatorMethod( exprNode, tableName, agg.ColumnName, streamNum, agg.Factory.ResultType, agg.MethodOffset)); } else { return(new ExprTableExprEvaluatorAccess( exprNode, tableName, agg.ColumnName, streamNum, agg.Factory.ResultType, agg.AccessAccessorSlotPair, agg.OptionalEventType)); } }
private AggregationMethodFactory ValidateAggregationInternal(ExprValidationContext validationContext, TableMetadataColumnAggregation optionalBinding) { ExprAggMultiFunctionSortedMinMaxByNodeFactory factory; // handle table-access expression (state provided, accessor needed) if (optionalBinding != null) factory = HandleTableAccess(optionalBinding); else if (validationContext.ExprEvaluatorContext.StatementType == StatementType.CREATE_TABLE) factory = HandleCreateTable(validationContext); else if (validationContext.IntoTableName != null) factory = HandleIntoTable(validationContext); else factory = HandleNonTable(validationContext); _containedType = factory.ContainedEventType; return factory; }
private ExprAggMultiFunctionSortedMinMaxByNodeFactory HandleTableAccess(TableMetadataColumnAggregation tableAccess) { var factory = (ExprAggMultiFunctionSortedMinMaxByNodeFactory)tableAccess.Factory; AggregationAccessor accessor; var componentType = factory.ContainedEventType.UnderlyingType; var accessorResultType = componentType; if (!_sortedwin) { accessor = new AggregationAccessorMinMaxByNonTable(_max); } else { accessor = new AggregationAccessorSortedNonTable(_max, componentType); accessorResultType = TypeHelper.GetArrayType(accessorResultType); } return(new ExprAggMultiFunctionSortedMinMaxByNodeFactory(this, accessor, accessorResultType, factory.ContainedEventType, null, null, null)); }
protected override void ValidateBindingInternal(ExprValidationContext validationContext, TableMetadata tableMetadata) { ValidateGroupKeys(tableMetadata); _eventType = new LinkedHashMap <string, object>(); foreach (var entry in tableMetadata.TableColumns) { Type classResult; if (entry.Value is TableMetadataColumnPlain) { classResult = tableMetadata.InternalEventType.GetPropertyType(entry.Key); } else { TableMetadataColumnAggregation aggcol = (TableMetadataColumnAggregation)entry.Value; classResult = TypeHelper.GetBoxedType(aggcol.Factory.ResultType); } _eventType.Put(entry.Key, classResult); } }
public PlugInAggregationMultiFunctionValidationContext( string functionName, EventType[] eventTypes, ExprNode[] parameterExpressions, string engineURI, string statementName, ExprValidationContext validationContext, ConfigurationPlugInAggregationMultiFunction config, TableMetadataColumnAggregation optionalTableColumnAccessed, IList <ExprNode> allParameterExpressions) { _functionName = functionName; _eventTypes = eventTypes; _parameterExpressions = parameterExpressions; _engineURI = engineURI; _statementName = statementName; _validationContext = validationContext; _config = config; _optionalTableColumnAccessed = optionalTableColumnAccessed; _allParameterExpressions = allParameterExpressions; }
/// <summary> /// Ctor. /// </summary> /// <param name="functionName">function name</param> /// <param name="eventTypes">event types</param> /// <param name="parameterExpressions">expressions</param> /// <param name="statementName">statement name</param> /// <param name="validationContext">validation context</param> /// <param name="config">configuration</param> /// <param name="optionalTableColumnRead">optional table column name</param> /// <param name="allParameterExpressions">all parameters</param> /// <param name="optionalFilterExpression">optional filter parameter</param> public AggregationMultiFunctionValidationContext( string functionName, EventType[] eventTypes, ExprNode[] parameterExpressions, string statementName, ExprValidationContext validationContext, ConfigurationCompilerPlugInAggregationMultiFunction config, TableMetadataColumnAggregation optionalTableColumnRead, ExprNode[] allParameterExpressions, ExprNode optionalFilterExpression) { FunctionName = functionName; EventTypes = eventTypes; ParameterExpressions = parameterExpressions; StatementName = statementName; ValidationContext = validationContext; Config = config; OptionalTableColumnRead = optionalTableColumnRead; AllParameterExpressions = allParameterExpressions; OptionalFilterExpression = optionalFilterExpression; }
/// <summary> /// Ctor. /// </summary> /// <param name="functionName">the aggregation function name</param> /// <param name="eventTypes">the event types of all events in the select clause</param> /// <param name="parameterExpressions">the parameter expressions</param> /// <param name="engineURI">the engine URI</param> /// <param name="statementName">the statement name</param> /// <param name="validationContext">additional validation contextual services</param> /// <param name="config">the original configuration object for the aggregation multi-function</param> /// <param name="optionalTableColumnAccessed">The optional table column accessed.</param> /// <param name="allParameterExpressions">All parameter expressions.</param> public PlugInAggregationMultiFunctionValidationContext( string functionName, EventType[] eventTypes, ExprNode[] parameterExpressions, string engineURI, string statementName, ExprValidationContext validationContext, ConfigurationPlugInAggregationMultiFunction config, TableMetadataColumnAggregation optionalTableColumnAccessed, ExprNode[] allParameterExpressions) { FunctionName = functionName; EventTypes = eventTypes; ParameterExpressions = parameterExpressions; EngineURI = engineURI; StatementName = statementName; ValidationContext = validationContext; Config = config; OptionalTableColumnAccessed = optionalTableColumnAccessed; AllParameterExpressions = allParameterExpressions; }
public AggregationTableReadDesc ValidateAggregationTableRead( ExprValidationContext validationContext, TableMetadataColumnAggregation tableAccessColumn, TableMetaData table) { var validation = tableAccessColumn.AggregationPortableValidation; if (!(validation is AggregationPortableValidationSorted)) { throw new ExprValidationException( "Invalid aggregation column type for column '" + tableAccessColumn.ColumnName + "'"); } var validationSorted = (AggregationPortableValidationSorted) validation; var componentType = validationSorted.ContainedEventType.UnderlyingType; if (!sortedwin) { var forgeX = new AggregationTAAReaderSortedMinMaxByForge(componentType, IsMax, table); return new AggregationTableReadDesc(forgeX, null, null, validationSorted.ContainedEventType); } var forge = new AggregationTAAReaderSortedWindowForge(TypeHelper.GetArrayType(componentType)); return new AggregationTableReadDesc(forge, validationSorted.ContainedEventType, null, null); }
protected internal static IDictionary<string, object> EvalMap( ObjectArrayBackedEventBean @event, AggregationRow row, IDictionary<string, TableMetadataColumn> items, EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext exprEvaluatorContext) { Dictionary<string, object> cols = new Dictionary<string, object>(); foreach (KeyValuePair<string, TableMetadataColumn> entry in items) { if (entry.Value is TableMetadataColumnPlain) { TableMetadataColumnPlain plain = (TableMetadataColumnPlain) entry.Value; cols.Put(entry.Key, @event.Properties[plain.IndexPlain]); } else { TableMetadataColumnAggregation aggcol = (TableMetadataColumnAggregation) entry.Value; cols.Put(entry.Key, row.GetValue(aggcol.Column, eventsPerStream, isNewData, exprEvaluatorContext)); } } return cols; }
private AggregationMethodFactory ValidateAggregationInternal( ExprValidationContext validationContext, TableMetadataColumnAggregation optionalBinding) { LinearAggregationFactoryDesc desc; // handle table-access expression (state provided, accessor needed) var positionalParams = PositionalParams; if (optionalBinding != null) desc = HandleTableAccess(positionalParams, StateType, validationContext, optionalBinding); else if (validationContext.ExprEvaluatorContext.StatementType == StatementType.CREATE_TABLE) desc = HandleCreateTable(positionalParams, StateType, validationContext); else if (validationContext.IntoTableName != null) desc = HandleIntoTable(positionalParams, StateType, validationContext); else desc = HandleNonIntoTable(positionalParams, StateType, validationContext); _containedType = desc.EnumerationEventType; _scalarCollectionComponentType = desc.ScalarCollectionType; return desc.Factory; }
public AggregationTableReadDesc ValidateAggregationTableRead( ExprValidationContext validationContext, TableMetadataColumnAggregation tableAccessColumn, TableMetaData table) { // child node validation ExprNodeUtilityValidate.GetValidatedSubtree(ExprNodeOrigin.AGGPARAM, ChildNodes, validationContext); // portable validation var validation = tableAccessColumn.AggregationPortableValidation; if (!(validation is AggregationPortableValidationPluginMultiFunc)) { throw new ExprValidationException("Invalid aggregation column type"); } // obtain handler var ctx = new AggregationMultiFunctionValidationContext( functionName, validationContext.StreamTypeService.EventTypes, positionalParams, validationContext.StatementName, validationContext, config, null, ChildNodes, optionalFilter); var handler = aggregationMultiFunctionForge.ValidateGetHandler(ctx); // set of reader var epType = handler.ReturnType; Type returnType = EPTypeHelper.GetNormalizedClass(epType); var forge = new AggregationTableAccessAggReaderForgePlugIn( returnType, (AggregationMultiFunctionTableReaderModeManaged) handler.TableReaderMode); EventType eventTypeCollection = EPTypeHelper.OptionalIsEventTypeColl(epType); EventType eventTypeSingle = EPTypeHelper.OptionalIsEventTypeSingle(epType); Type componentTypeCollection = EPTypeHelper.OptionalIsComponentTypeColl(epType); return new AggregationTableReadDesc(forge, eventTypeCollection, componentTypeCollection, eventTypeSingle); }
private LinearAggregationFactoryDesc HandleTableAccessFirstLast( ExprNode[] childNodes, AggregationStateType stateType, ExprValidationContext validationContext, TableMetadataColumnAggregation tableAccess) { var original = (ExprAggMultiFunctionLinearAccessNodeFactoryAccess) tableAccess.Factory; var resultType = original.ContainedEventType.UnderlyingType; var defaultAccessor = stateType == AggregationStateType.FIRST ? AggregationAccessorFirstNoEval.INSTANCE : (AggregationAccessor) AggregationAccessorLastNoEval.INSTANCE; if (childNodes.Length == 0) { var factoryAccess = new ExprAggMultiFunctionLinearAccessNodeFactoryAccess(this, defaultAccessor, resultType, original.ContainedEventType, null, null, null); return new LinearAggregationFactoryDesc(factoryAccess, factoryAccess.ContainedEventType, null); } if (childNodes.Length == 1) { if (childNodes[0] is ExprWildcard) { var factoryAccess = new ExprAggMultiFunctionLinearAccessNodeFactoryAccess(this, defaultAccessor, resultType, original.ContainedEventType, null, null, null); return new LinearAggregationFactoryDesc(factoryAccess, factoryAccess.ContainedEventType, null); } if (childNodes[0] is ExprStreamUnderlyingNode) throw new ExprValidationException("Stream-wildcard is not allowed for table column access"); // Expressions apply to events held, thereby validate in terms of event value expressions var paramNode = childNodes[0]; var streams = TableServiceUtil.StreamTypeFromTableColumn(tableAccess, validationContext.StreamTypeService.EngineURIQualifier); var localValidationContext = new ExprValidationContext(streams, validationContext); paramNode = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.AGGPARAM, paramNode, localValidationContext); var paramNodeEval = paramNode.ExprEvaluator; AggregationAccessor accessor; if (stateType == AggregationStateType.FIRST) accessor = new AggregationAccessorFirstWEval(0, paramNodeEval); else accessor = new AggregationAccessorLastWEval(0, paramNodeEval); var factory = new ExprAggMultiFunctionLinearAccessNodeFactoryAccess( this, accessor, paramNodeEval.ReturnType, original.ContainedEventType, null, null, null); return new LinearAggregationFactoryDesc(factory, factory.ContainedEventType, null); } if (childNodes.Length == 2) { var isFirst = stateType == AggregationStateType.FIRST; var constant = -1; var indexEvalNode = childNodes[1]; if (indexEvalNode.IsConstantResult) constant = indexEvalNode.ExprEvaluator.Evaluate(EvaluateParams.EmptyTrue).AsInt(); var evaluatorIndex = indexEvalNode.ExprEvaluator; if (evaluatorIndex.ReturnType.IsInt32()) { throw new ExprValidationException( GetErrorPrefix(stateType) + " requires a constant index expression that returns an integer value"); } var accessor = new AggregationAccessorFirstLastIndexNoEval(evaluatorIndex, constant, isFirst); var factory = new ExprAggMultiFunctionLinearAccessNodeFactoryAccess(this, accessor, resultType, original.ContainedEventType, null, null, null); return new LinearAggregationFactoryDesc(factory, factory.ContainedEventType, null); } throw new ExprValidationException("Invalid number of parameters"); }
public AggregationMethodFactory ValidateAggregationParamsWBinding(ExprValidationContext validationContext, TableMetadataColumnAggregation tableAccessColumn) { return(ValidateAggregationInternal(validationContext, tableAccessColumn)); }
private AggregationMethodFactory ValidateAggregationInternal(ExprValidationContext context, TableMetadataColumnAggregation tableAccessColumn) { if (IsDistinct) { throw new ExprValidationException(MessagePrefix + "is not supported with distinct"); } // for declaration, validate the specification and return the state factory if (_aggType == CountMinSketchAggType.STATE) { if (context.ExprEvaluatorContext.StatementType != StatementType.CREATE_TABLE) { throw new ExprValidationException(MessagePrefix + "can only be used in create-table statements"); } var specification = ValidateSpecification(context); var stateFactory = context.EngineImportService.AggregationFactoryFactory.MakeCountMinSketch(context.StatementExtensionSvcContext, this, specification); return(new ExprAggCountMinSketchNodeFactoryState(stateFactory)); } var positionalParams = PositionalParams; // validate number of parameters if (_aggType == CountMinSketchAggType.ADD || _aggType == CountMinSketchAggType.FREQ) { if (positionalParams.Length == 0 || positionalParams.Length > 1) { throw new ExprValidationException(MessagePrefix + "requires a single parameter expression"); } } else { if (positionalParams.Length != 0) { throw new ExprValidationException(MessagePrefix + "requires a no parameter expressions"); } } // validate into-table and table-access if (_aggType == CountMinSketchAggType.ADD) { if (context.IntoTableName == null) { throw new ExprValidationException(MessagePrefix + "can only be used with into-table"); } } else { if (tableAccessColumn == null) { throw new ExprValidationException(MessagePrefix + "requires the use of a table-access expression"); } ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.AGGPARAM, ChildNodes, context); } // obtain evaluator ExprEvaluator addOrFrequencyEvaluator = null; if (_aggType == CountMinSketchAggType.ADD || _aggType == CountMinSketchAggType.FREQ) { addOrFrequencyEvaluator = ChildNodes[0].ExprEvaluator; } return(new ExprAggCountMinSketchNodeFactoryUse(this, addOrFrequencyEvaluator)); }
public AggregationMethodFactory ValidateAggregationParamsWBinding(ExprValidationContext validationContext, TableMetadataColumnAggregation tableAccessColumn) { // validate using the context provided by the 'outside' streams to determine parameters // at this time 'inside' expressions like 'window(intPrimitive)' are not handled ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.AGGPARAM, ChildNodes, validationContext); return(ValidateAggregationInternal(validationContext, tableAccessColumn)); }
private AggregationMethodFactory ValidateAggregationInternal(ExprValidationContext validationContext, TableMetadataColumnAggregation optionalTableColumn) { var ctx = new PlugInAggregationMultiFunctionValidationContext( _functionName, validationContext.StreamTypeService.EventTypes, PositionalParams, validationContext.StreamTypeService.EngineURIQualifier, validationContext.StatementName, validationContext, _config, optionalTableColumn, ChildNodes); var handlerPlugin = _pluginAggregationMultiFunctionFactory.ValidateGetHandler(ctx); _factory = new ExprPlugInAggMultiFunctionNodeFactory(this, handlerPlugin, validationContext.EngineImportService.AggregationFactoryFactory, validationContext.StatementExtensionSvcContext); return(_factory); }