public ExprPlugInMultiFunctionAggNode(
bool distinct,
ConfigurationCompilerPlugInAggregationMultiFunction config,
AggregationMultiFunctionForge aggregationMultiFunctionForge,
string functionName)
: base(distinct)
{
this.aggregationMultiFunctionForge = aggregationMultiFunctionForge;
this.functionName = functionName;
this.config = config;
}
public static ExprNode TryResolveAsAggregation(
ImportServiceCompileTime importService,
bool distinct,
string functionName,
LazyAllocatedMap<HashableMultiKey, AggregationMultiFunctionForge> plugInAggregations,
ClassProvidedExtension classProvidedExtension)
{
try {
AggregationFunctionForge aggregationFactory = importService.ResolveAggregationFunction(functionName, classProvidedExtension);
return new ExprPlugInAggNode(distinct, aggregationFactory, functionName);
}
catch (ImportUndefinedException) {
// Not an aggregation function
}
catch (ImportException e) {
throw new ValidationException("Error resolving aggregation: " + e.Message, e);
}
// try plug-in aggregation multi-function
Pair<ConfigurationCompilerPlugInAggregationMultiFunction, Type> configPair = importService
.ResolveAggregationMultiFunction(functionName, classProvidedExtension);
if (configPair != null) {
HashableMultiKey multiKey = new HashableMultiKey(configPair.First.FunctionNames);
AggregationMultiFunctionForge factory = plugInAggregations.Map.Get(multiKey);
if (factory == null) {
if (configPair.Second != null) {
factory = (AggregationMultiFunctionForge) TypeHelper.Instantiate<AggregationMultiFunctionForge>(
configPair.Second);
} else {
factory = (AggregationMultiFunctionForge) TypeHelper.Instantiate<AggregationMultiFunctionForge>(
configPair.First.MultiFunctionForgeClassName, importService.ClassForNameProvider);
}
plugInAggregations.Map[multiKey] = factory;
}
factory.AddAggregationFunction(new AggregationMultiFunctionDeclarationContext(
functionName.ToLowerInvariant(),
distinct,
configPair.First));
return new ExprPlugInMultiFunctionAggNode(distinct, configPair.First, factory, functionName);
}
// try built-in expanded set of aggregation functions
return importService.ResolveAggExtendedBuiltin(functionName, distinct);
}
public static ExprNode TryResolveAsAggregation(
ImportServiceCompileTime importService,
bool distinct,
string functionName,
LazyAllocatedMap<ConfigurationCompilerPlugInAggregationMultiFunction, AggregationMultiFunctionForge>
plugInAggregations)
{
try {
AggregationFunctionForge aggregationFactory = importService.ResolveAggregationFunction(functionName);
return new ExprPlugInAggNode(distinct, aggregationFactory, functionName);
}
catch (ImportUndefinedException) {
// Not an aggregation function
}
catch (ImportException e) {
throw new ValidationException("Error resolving aggregation: " + e.Message, e);
}
// try plug-in aggregation multi-function
ConfigurationCompilerPlugInAggregationMultiFunction config =
importService.ResolveAggregationMultiFunction(functionName);
if (config != null) {
AggregationMultiFunctionForge factory = plugInAggregations.Map.Get(config);
if (factory == null) {
factory = (AggregationMultiFunctionForge) TypeHelper.Instantiate<AggregationMultiFunctionForge>(
config.MultiFunctionForgeClassName,
importService.ClassForNameProvider);
plugInAggregations.Map.Put(config, factory);
}
factory.AddAggregationFunction(
new AggregationMultiFunctionDeclarationContext(functionName.ToLowerInvariant(), distinct, config));
return new ExprPlugInMultiFunctionAggNode(distinct, config, factory, functionName);
}
// try built-in expanded set of aggregation functions
return importService.ResolveAggExtendedBuiltin(functionName, distinct);
}
