static ExcludePlanHintExprUtil()
{
LinkedHashMap<string, object> properties = new LinkedHashMap<string, object>();
properties.Put("from_streamnum", typeof(int?));
properties.Put("to_streamnum", typeof(int?));
properties.Put("from_streamname", typeof(string));
properties.Put("to_streamname", typeof(string));
properties.Put("opname", typeof(string));
properties.Put("exprs", typeof(string[]));
string eventTypeName = EventTypeNameUtil.GetAnonymousTypeNameExcludePlanHint();
EventTypeMetadata eventTypeMetadata = new EventTypeMetadata(
eventTypeName,
null,
EventTypeTypeClass.EXCLUDEPLANHINTDERIVED,
EventTypeApplicationType.OBJECTARR,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
OAEXPRESSIONTYPE = BaseNestableEventUtil.MakeOATypeCompileTime(
eventTypeMetadata,
properties,
null,
null,
null,
null,
new BeanEventTypeFactoryDisallow(EventBeanTypedEventFactoryCompileTime.INSTANCE),
null);
}
public TableMetaData ResolveTableFromEventType(EventType containedType)
{
if (containedType != null && containedType.Metadata.TypeClass == EventTypeTypeClass.TABLE_INTERNAL) {
string tableName = EventTypeNameUtil.GetTableNameFromInternalTypeName(containedType.Name);
return Resolve(tableName);
}
return null;
}
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);
}
