public CodegenExpression MakeProvider(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
CodegenMethod method = parent.MakeChild(typeof(AggregationServiceFactoryTable), this.GetType(), classScope);
method.Block
.DeclareVar<AggregationServiceFactoryTable>(
"factory",
NewInstance(typeof(AggregationServiceFactoryTable)))
.SetProperty(
Ref("factory"),
"Table",
TableDeployTimeResolver.MakeResolveTable(metadata, symbols.GetAddInitSvc(method)))
.SetProperty(
Ref("factory"),
"MethodPairs",
TableColumnMethodPairForge.MakeArray(methodPairs, method, symbols, classScope))
.SetProperty(Ref("factory"), "AccessColumnsZeroOffset", Constant(accessColumnsZeroOffset))
.SetProperty(
Ref("factory"),
"AccessAgents",
AggregationAgentUtil.MakeArray(accessAgents, method, symbols, classScope))
.SetProperty(
Ref("factory"),
"GroupByRollupDesc",
groupByRollupDesc == null ? ConstantNull() : groupByRollupDesc.Codegen(method, classScope))
.MethodReturn(Ref("factory"));
return LocalMethod(method);
}
private static BindingMatchResult MatchBindingsAssignColumnNumbers(
IntoTableSpec bindings,
TableMetaData metadata,
IList<AggregationServiceAggExpressionDesc> aggregations,
IDictionary<ExprNode, string> selectClauseNamedNodes,
IList<ExprForge[]> methodAggForgesList,
IList<ExprDeclaredNode> declaredExpressions,
ImportService importService,
string statementName)
{
IDictionary<AggregationServiceAggExpressionDesc, TableMetadataColumnAggregation> methodAggs =
new LinkedHashMap<AggregationServiceAggExpressionDesc, TableMetadataColumnAggregation>();
IDictionary<AggregationServiceAggExpressionDesc, TableMetadataColumnAggregation> accessAggs =
new LinkedHashMap<AggregationServiceAggExpressionDesc, TableMetadataColumnAggregation>();
foreach (var aggDesc in aggregations) {
// determine assigned name
var columnName = FindColumnNameForAggregation(
selectClauseNamedNodes,
declaredExpressions,
aggDesc.AggregationNode);
if (columnName == null) {
throw new ExprValidationException(
"Failed to find an expression among the select-clause expressions for expression '" +
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(aggDesc.AggregationNode) +
"'");
}
// determine binding metadata
var columnMetadata = (TableMetadataColumnAggregation) metadata.Columns.Get(columnName);
if (columnMetadata == null) {
throw new ExprValidationException(
"Failed to find name '" + columnName + "' among the columns for table '" + bindings.Name + "'");
}
// validate compatible
ValidateIntoTableCompatible(bindings.Name, columnName, columnMetadata, aggDesc);
if (columnMetadata.IsMethodAgg) {
methodAggs.Put(aggDesc, columnMetadata);
}
else {
accessAggs.Put(aggDesc, columnMetadata);
}
}
// handle method-aggs
var methodPairs = new TableColumnMethodPairForge[methodAggForgesList.Count];
var methodIndex = -1;
foreach (var methodEntry in methodAggs) {
methodIndex++;
var column = methodEntry.Value.Column;
ExprForge[] forges = methodAggForgesList[methodIndex];
methodPairs[methodIndex] = new TableColumnMethodPairForge(
forges,
column,
methodEntry.Key.AggregationNode);
methodEntry.Key.SetColumnNum(column);
}
// handle access-aggs
IDictionary<int, ExprNode> accessSlots = new LinkedHashMap<int, ExprNode>();
IList<AggregationAccessorSlotPairForge> accessReadPairs = new List<AggregationAccessorSlotPairForge>();
var accessIndex = -1;
IList<AggregationAgentForge> agents = new List<AggregationAgentForge>();
foreach (var accessEntry in accessAggs) {
accessIndex++;
var column = accessEntry.Value.Column; // Slot is zero-based as we enter with zero-offset
var aggregationMethodFactory = accessEntry.Key.Factory;
var accessorForge = aggregationMethodFactory.AccessorForge;
accessSlots.Put(column, accessEntry.Key.AggregationNode);
accessReadPairs.Add(new AggregationAccessorSlotPairForge(column, accessorForge));
accessEntry.Key.SetColumnNum(column);
agents.Add(aggregationMethodFactory.GetAggregationStateAgent(importService, statementName));
}
var agentArr = agents.ToArray();
var accessReads = accessReadPairs.ToArray();
var targetStates = new int[accessSlots.Count];
var accessStateExpr = new ExprNode[accessSlots.Count];
var count = 0;
foreach (var entry in accessSlots) {
targetStates[count] = entry.Key;
accessStateExpr[count] = entry.Value;
count++;
}
return new BindingMatchResult(methodPairs, accessReads, targetStates, accessStateExpr, agentArr);
}
