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);
}
