/// <summary>Ctor. </summary>
/// <param name="distinct">flag indicating unique or non-unique value aggregation</param>
/// <param name="aggregationFunctionFactory">is the base class for plug-in aggregation functions</param>
/// <param name="functionName">is the aggregation function name</param>
public ExprPlugInAggFunctionFactoryNode(bool distinct, AggregationFunctionFactory aggregationFunctionFactory, String functionName)
: base(distinct)
{
_aggregationFunctionFactory = aggregationFunctionFactory;
_functionName = functionName;
aggregationFunctionFactory.FunctionName = functionName;
}
public AggregationMethodFactoryPlugIn(ExprPlugInAggNode parent,
AggregationFunctionFactory aggregationFunctionFactory, Type aggregatedValueType)
{
_parent = parent;
_aggregationFunctionFactory = aggregationFunctionFactory;
_aggregatedValueType = aggregatedValueType;
}
public AggregationMethodFactory MakePlugInMethod(
StatementExtensionSvcContext statementExtensionSvcContext,
ExprPlugInAggNode expr,
AggregationFunctionFactory factory,
Type childType)
{
return(new AggregationMethodFactoryPlugIn(expr, factory, childType));
}
public static ExprNode TryResolveAsAggregation(
EngineImportService engineImportService,
bool distinct,
String functionName,
LazyAllocatedMap <ConfigurationPlugInAggregationMultiFunction, PlugInAggregationMultiFunctionFactory> plugInAggregations,
String engineURI)
{
try
{
AggregationFunctionFactory aggregationFactory = engineImportService.ResolveAggregationFactory(functionName);
return(new ExprPlugInAggNode(distinct, aggregationFactory, functionName));
}
catch (EngineImportUndefinedException)
{
// Not an aggregation function
}
catch (EngineImportException e)
{
throw new IllegalStateException("Error resolving aggregation: " + e.Message, e);
}
// try plug-in aggregation multi-function
ConfigurationPlugInAggregationMultiFunction config =
engineImportService.ResolveAggregationMultiFunction(functionName);
if (config != null)
{
PlugInAggregationMultiFunctionFactory factory = plugInAggregations.Map.Get(config);
if (factory == null)
{
factory = TypeHelper.Instantiate <PlugInAggregationMultiFunctionFactory>(
config.MultiFunctionFactoryClassName);
plugInAggregations.Map.Put(config, factory);
}
factory.AddAggregationFunction(
new PlugInAggregationMultiFunctionDeclarationContext(
functionName.ToLower(), distinct, engineURI, config));
return(new ExprPlugInAggMultiFunctionNode(distinct, config, factory, functionName));
}
// try built-in expanded set of aggregation functions
return(engineImportService.ResolveAggExtendedBuiltin(functionName, distinct));
}
public override AggregationMethodFactory ValidateAggregationChild(ExprValidationContext validationContext)
{
var positionalParams = PositionalParams;
var parameterTypes = new Type[positionalParams.Length];
var constant = new Object[positionalParams.Length];
var isConstant = new bool[positionalParams.Length];
var expressions = new ExprNode[positionalParams.Length];
var count = 0;
var hasDataWindows = true;
var evaluateParams = new EvaluateParams(null, true, validationContext.ExprEvaluatorContext);
foreach (var child in positionalParams)
{
if (child.IsConstantResult)
{
isConstant[count] = true;
constant[count] = child.ExprEvaluator.Evaluate(evaluateParams);
}
parameterTypes[count] = child.ExprEvaluator.ReturnType;
expressions[count] = child;
if (!ExprNodeUtility.HasRemoveStreamForAggregations(child, validationContext.StreamTypeService, validationContext.IsResettingAggregations))
{
hasDataWindows = false;
}
if (child is ExprWildcard)
{
ExprAggMultiFunctionUtil.CheckWildcardNotJoinOrSubquery(validationContext.StreamTypeService, _functionName);
parameterTypes[count] = validationContext.StreamTypeService.EventTypes[0].UnderlyingType;
isConstant[count] = false;
constant[count] = null;
}
count++;
}
var context = new AggregationValidationContext(parameterTypes, isConstant, constant, base.IsDistinct, hasDataWindows, expressions);
try
{
// the aggregation function factory is transient, obtain if not provided
if (_aggregationFunctionFactory == null)
{
_aggregationFunctionFactory = validationContext.MethodResolutionService.EngineImportService.ResolveAggregationFactory(_functionName);
}
_aggregationFunctionFactory.Validate(context);
}
catch (Exception ex)
{
throw new ExprValidationException("Plug-in aggregation function '" + _functionName + "' failed validation: " + ex.Message, ex);
}
Type childType = null;
if (positionalParams.Length > 0)
{
childType = positionalParams[0].ExprEvaluator.ReturnType;
}
return(new ExprPlugInAggFunctionFactory(this, _aggregationFunctionFactory, childType));
}
public ExprPlugInAggFunctionFactory(ExprPlugInAggFunctionFactoryNode parent, AggregationFunctionFactory aggregationFunctionFactory, Type aggregatedValueType)
{
this._parent = parent;
this._aggregationFunctionFactory = aggregationFunctionFactory;
this._aggregatedValueType = aggregatedValueType;
}
