public AggregationAccessorForgeGetCodegenContext(
int column,
CodegenClassScope classScope,
AggregationStateFactoryForge accessStateForge,
CodegenMethod method,
CodegenNamedMethods namedMethods)
{
Column = column;
ClassScope = classScope;
AccessStateForge = accessStateForge;
Method = method;
NamedMethods = namedMethods;
}
public AggregationForgeFactoryAccessLinear(
ExprAggMultiFunctionLinearAccessNode parent,
AggregationAccessorForge accessor,
Type accessorResultType,
AggregationMultiFunctionStateKey optionalStateKey,
AggregationStateFactoryForge optionalStateFactory,
AggregationAgentForge optionalAgent,
EventType containedEventType)
{
this.parent = parent;
AccessorForge = accessor;
ResultType = accessorResultType;
this.optionalStateKey = optionalStateKey;
this.optionalStateFactory = optionalStateFactory;
this.optionalAgent = optionalAgent;
this.containedEventType = containedEventType;
}
// handle accessor aggregation (direct data window by-group access to properties)
public static AggregationMultiFunctionAnalysisResult AnalyzeAccessAggregations(
IList<AggregationServiceAggExpressionDesc> aggregations,
ImportServiceCompileTime importService,
bool isFireAndForget,
string statementName,
ExprNode[] groupByNodes)
{
var currentSlot = 0;
Deque<AggregationMFIdentifier> accessProviderSlots = new ArrayDeque<AggregationMFIdentifier>();
IList<AggregationAccessorSlotPairForge> accessorPairsForges = new List<AggregationAccessorSlotPairForge>();
IList<AggregationStateFactoryForge> stateFactoryForges = new List<AggregationStateFactoryForge>();
foreach (var aggregation in aggregations) {
var aggregateNode = aggregation.AggregationNode;
if (!aggregateNode.Factory.IsAccessAggregation) {
continue;
}
AggregationMultiFunctionStateKey providerKey = aggregateNode.Factory.GetAggregationStateKey(false);
var existing = FindExisting(
accessProviderSlots,
providerKey,
aggregateNode.OptionalLocalGroupBy,
groupByNodes);
int slot;
if (existing == null) {
accessProviderSlots.Add(
new AggregationMFIdentifier(providerKey, aggregateNode.OptionalLocalGroupBy, currentSlot));
slot = currentSlot++;
AggregationStateFactoryForge
providerForge = aggregateNode.Factory.GetAggregationStateFactory(false);
stateFactoryForges.Add(providerForge);
}
else {
slot = existing.Slot;
}
AggregationAccessorForge accessorForge = aggregateNode.Factory.AccessorForge;
accessorPairsForges.Add(new AggregationAccessorSlotPairForge(slot, accessorForge));
}
AggregationAccessorSlotPairForge[] forges = accessorPairsForges.ToArray();
AggregationStateFactoryForge[] accessForges = stateFactoryForges.ToArray();
return new AggregationMultiFunctionAnalysisResult(forges, accessForges);
}
private TableAccessAnalysisResult AnalyzePlanAggregations(
string tableName,
IList<TableColumnDesc> columns,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
// once upfront: obtains aggregation factories for each aggregation
// we do this once as a factory may be a heavier object
IDictionary<TableColumnDesc, AggregationForgeFactory> aggregationFactories =
new Dictionary<TableColumnDesc, AggregationForgeFactory>();
foreach (var column in columns) {
if (column is TableColumnDescAgg) {
var agg = (TableColumnDescAgg) column;
var factory = agg.Aggregation.Factory;
aggregationFactories.Put(column, factory);
}
}
// sort into these categories:
// plain / method-agg / access-agg
// compile all-column public types
IList<TableColumnDescTyped> plainColumns = new List<TableColumnDescTyped>();
IList<TableColumnDescAgg> methodAggColumns = new List<TableColumnDescAgg>();
IList<TableColumnDescAgg> accessAggColumns = new List<TableColumnDescAgg>();
var allColumnsPublicTypes = new LinkedHashMap<string, object>();
foreach (var column in columns) {
// handle plain types
if (column is TableColumnDescTyped) {
var typed = (TableColumnDescTyped) column;
plainColumns.Add(typed);
allColumnsPublicTypes.Put(column.ColumnName, typed.UnresolvedType);
continue;
}
// handle aggs
var agg = (TableColumnDescAgg) column;
var aggFactory = aggregationFactories.Get(agg);
if (aggFactory.IsAccessAggregation) {
accessAggColumns.Add(agg);
}
else {
methodAggColumns.Add(agg);
}
allColumnsPublicTypes.Put(column.ColumnName, agg.Aggregation.EvaluationType);
}
// determine column metadata
//
var columnMetadata = new LinkedHashMap<string, TableMetadataColumn>();
// handle typed columns
var allColumnsInternalTypes = new LinkedHashMap<string, object>();
allColumnsInternalTypes.Put(INTERNAL_RESERVED_PROPERTY, typeof(object));
var indexPlain = 1;
var assignPairsPlain = new TableMetadataColumnPairPlainCol[plainColumns.Count];
foreach (var typedColumn in plainColumns) {
allColumnsInternalTypes.Put(typedColumn.ColumnName, typedColumn.UnresolvedType);
columnMetadata.Put(
typedColumn.ColumnName,
new TableMetadataColumnPlain(typedColumn.ColumnName, typedColumn.IsKey, indexPlain));
assignPairsPlain[indexPlain - 1] = new TableMetadataColumnPairPlainCol(
typedColumn.PositionInDeclaration,
indexPlain);
indexPlain++;
}
// determine internally-used event type
var visibility = services.ModuleVisibilityRules.GetAccessModifierTable(@base, tableName);
var internalName = EventTypeNameUtil.GetTableInternalTypeName(tableName);
var internalMetadata = new EventTypeMetadata(
internalName,
@base.ModuleName,
EventTypeTypeClass.TABLE_INTERNAL,
EventTypeApplicationType.OBJECTARR,
visibility,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var internalEventType = BaseNestableEventUtil.MakeOATypeCompileTime(
internalMetadata,
allColumnsInternalTypes,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(internalEventType);
// for use by indexes and lookups
var publicName = EventTypeNameUtil.GetTablePublicTypeName(tableName);
var publicMetadata = new EventTypeMetadata(
publicName,
@base.ModuleName,
EventTypeTypeClass.TABLE_PUBLIC,
EventTypeApplicationType.OBJECTARR,
visibility,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var publicEventType = BaseNestableEventUtil.MakeOATypeCompileTime(
publicMetadata,
allColumnsPublicTypes,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(publicEventType);
// handle aggregation-methods single-func first.
var methodFactories = new AggregationForgeFactory[methodAggColumns.Count];
var index = 0;
var assignPairsMethod = new TableMetadataColumnPairAggMethod[methodAggColumns.Count];
foreach (var column in methodAggColumns) {
var factory = aggregationFactories.Get(column);
var optionalEnumerationType = EPTypeHelper.OptionalFromEnumerationExpr(
statementRawInfo,
services,
column.Aggregation);
methodFactories[index] = factory;
var bindingInfo = factory.AggregationPortableValidation;
var expression =
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(factory.AggregationExpression);
columnMetadata.Put(
column.ColumnName,
new TableMetadataColumnAggregation(
column.ColumnName,
false,
index,
bindingInfo,
expression,
true,
optionalEnumerationType));
assignPairsMethod[index] = new TableMetadataColumnPairAggMethod(column.PositionInDeclaration);
index++;
}
// handle access-aggregation (sharable, multi-value) aggregations
var stateFactories = new AggregationStateFactoryForge[accessAggColumns.Count];
var accessAccessorForges = new AggregationAccessorSlotPairForge[accessAggColumns.Count];
var assignPairsAccess = new TableMetadataColumnPairAggAccess[accessAggColumns.Count];
var accessNum = 0;
foreach (var column in accessAggColumns) {
var factory = aggregationFactories.Get(column);
var forge = factory.GetAggregationStateFactory(false);
stateFactories[accessNum] = forge;
var accessor = factory.AccessorForge;
var bindingInfo = factory.AggregationPortableValidation;
accessAccessorForges[accessNum] = new AggregationAccessorSlotPairForge(accessNum, accessor);
var expression =
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(factory.AggregationExpression);
var optionalEnumerationType = EPTypeHelper.OptionalFromEnumerationExpr(
statementRawInfo,
services,
column.Aggregation);
columnMetadata.Put(
column.ColumnName,
new TableMetadataColumnAggregation(
column.ColumnName,
false,
index,
bindingInfo,
expression,
false,
optionalEnumerationType));
assignPairsAccess[accessNum] =
new TableMetadataColumnPairAggAccess(column.PositionInDeclaration, accessor);
index++;
accessNum++;
}
// determine primary key index information
var primaryKeyColumns = new List<string>();
var primaryKeyTypes = new List<Type>();
var primaryKeyGetters = new List<EventPropertyGetterSPI>();
var primaryKeyColNums = new List<int>();
var colNum = -1;
foreach (var typedColumn in plainColumns) {
colNum++;
if (typedColumn.IsKey) {
primaryKeyColumns.Add(typedColumn.ColumnName);
primaryKeyTypes.Add(internalEventType.GetPropertyType(typedColumn.ColumnName));
primaryKeyGetters.Add(internalEventType.GetGetterSPI(typedColumn.ColumnName));
primaryKeyColNums.Add(colNum + 1);
}
}
string[] primaryKeyColumnArray = null;
Type[] primaryKeyTypeArray = null;
EventPropertyGetterSPI[] primaryKeyGetterArray = null;
int[] primaryKeyColNumsArray = null;
if (!primaryKeyColumns.IsEmpty()) {
primaryKeyColumnArray = primaryKeyColumns.ToArray();
primaryKeyTypeArray = primaryKeyTypes.ToArray();
primaryKeyGetterArray = primaryKeyGetters.ToArray();
primaryKeyColNumsArray = primaryKeyColNums.ToArray();
}
var forgeDesc = new AggregationRowStateForgeDesc(
methodFactories,
null,
stateFactories,
accessAccessorForges,
new AggregationUseFlags(false, false, false));
var multiKeyPlan = MultiKeyPlanner.PlanMultiKey(
primaryKeyTypeArray, false, statementRawInfo, services.SerdeResolver);
var propertyForges = new DataInputOutputSerdeForge[internalEventType.PropertyNames.Length - 1];
var additionalForgeables = new List<StmtClassForgeableFactory>(multiKeyPlan.MultiKeyForgeables);
for (var i = 1; i < internalEventType.PropertyNames.Length; i++) {
var propertyName = internalEventType.PropertyNames[i];
var propertyType = internalEventType.Types.Get(propertyName);
var desc = SerdeEventPropertyUtility.ForgeForEventProperty(
publicEventType, propertyName, propertyType, statementRawInfo, services.SerdeResolver);
propertyForges[i - 1] = desc.Forge;
// plan serdes for nested types
foreach (var eventType in desc.NestedTypes) {
var serdeForgeables = SerdeEventTypeUtility.Plan(
eventType,
statementRawInfo,
services.SerdeEventTypeRegistry,
services.SerdeResolver);
additionalForgeables.AddAll(serdeForgeables);
}
}
return new TableAccessAnalysisResult(
columnMetadata,
internalEventType,
propertyForges,
publicEventType,
assignPairsPlain,
assignPairsMethod,
assignPairsAccess,
forgeDesc,
primaryKeyColumnArray,
primaryKeyGetterArray,
primaryKeyTypeArray,
primaryKeyColNumsArray,
multiKeyPlan.ClassRef,
additionalForgeables);
}
