/// <summary> /// Walks the chain of lookups and constructs lookup strategy and plan specification based /// on the index specifications. /// </summary> /// <param name="lookupStream">the stream to construct the query plan for</param> /// <param name="bestChain">the chain that the lookup follows to make best use of indexes</param> /// <param name="queryGraph">the repository for key properties to indexes</param> /// <param name="indexSpecsPerStream">specifications of indexes</param> /// <param name="typesPerStream">event types for each stream</param> /// <param name="isHistorical">indicator for each stream if it is a historical streams or not</param> /// <param name="historicalStreamIndexLists">index management, populated for the query plan</param> /// <param name="tablesPerStream">tables</param> /// <param name="streamJoinAnalysisResult">stream join analysis</param> /// <param name="raw">raw statement information</param> /// <param name="serdeResolver">serde resolver</param> /// <returns>NestedIterationNode with lookups attached underneath</returns> public static QueryPlanNodeForgeDesc CreateStreamPlan( int lookupStream, int[] bestChain, QueryGraphForge queryGraph, QueryPlanIndexForge[] indexSpecsPerStream, EventType[] typesPerStream, bool[] isHistorical, HistoricalStreamIndexListForge[] historicalStreamIndexLists, TableMetaData[] tablesPerStream, StreamJoinAnalysisResultCompileTime streamJoinAnalysisResult, StatementRawInfo raw, SerdeCompileTimeResolver serdeResolver) { var nestedIterNode = new NestedIterationNodeForge(bestChain); var currentLookupStream = lookupStream; var additionalForgeables = new List<StmtClassForgeableFactory>(); // Walk through each successive lookup for (var i = 0; i < bestChain.Length; i++) { var indexedStream = bestChain[i]; QueryPlanNodeForge node; if (isHistorical[indexedStream]) { if (historicalStreamIndexLists[indexedStream] == null) { historicalStreamIndexLists[indexedStream] = new HistoricalStreamIndexListForge( indexedStream, typesPerStream, queryGraph); } historicalStreamIndexLists[indexedStream].AddIndex(currentLookupStream); node = new HistoricalDataPlanNodeForge( indexedStream, lookupStream, currentLookupStream, typesPerStream.Length, null); } else { var tableLookupPlan = CreateLookupPlan( queryGraph, currentLookupStream, indexedStream, streamJoinAnalysisResult.IsVirtualDW(indexedStream), indexSpecsPerStream[indexedStream], typesPerStream, tablesPerStream[indexedStream], raw, serdeResolver); node = new TableLookupNodeForge(tableLookupPlan.Forge); additionalForgeables.AddAll(tableLookupPlan.AdditionalForgeables); } nestedIterNode.AddChildNode(node); currentLookupStream = bestChain[i]; } return new QueryPlanNodeForgeDesc(nestedIterNode, additionalForgeables); }
public static IList <StmtClassForgeableFactory> Plan( EventType eventType, StatementRawInfo raw, SerdeEventTypeCompileTimeRegistry registry, SerdeCompileTimeResolver resolver) { // there is no need to register a serde when not using HA, or when it is already registered, or for table-internal type var typeClass = eventType.Metadata.TypeClass; if (!registry.IsTargetHA || registry.EventTypes.ContainsKey(eventType) || typeClass == EventTypeTypeClass.TABLE_INTERNAL) { return(EmptyList <StmtClassForgeableFactory> .Instance); } // there is also no need to register a serde when using a public object var statementType = raw.StatementType; if ((typeClass == EventTypeTypeClass.NAMED_WINDOW && statementType != StatementType.CREATE_WINDOW) || (typeClass == EventTypeTypeClass.TABLE_PUBLIC && statementType != StatementType.CREATE_TABLE)) { return(EmptyList <StmtClassForgeableFactory> .Instance); } IList <StmtClassForgeableFactory> forgeables = new List <StmtClassForgeableFactory>(2); PlanRecursive(forgeables, eventType, raw, registry, resolver); return(forgeables); }
public static MultiKeyPlan PlanMultiKey( ExprForge[] criteriaExpressions, bool lenientEquals, StatementRawInfo raw, SerdeCompileTimeResolver serdeResolver) { return(PlanMultiKey(ExprNodeUtilityQuery.GetExprResultTypes(criteriaExpressions), lenientEquals, raw, serdeResolver)); }
private static SerdeAndForgeables PlanBean( BeanEventType eventType, StatementRawInfo raw, SerdeCompileTimeResolver resolver) { var forge = resolver.SerdeForBeanEventType(raw, eventType.UnderlyingType, eventType.Name, eventType.SuperTypes); return(new SerdeAndForgeables(forge, EmptyList <StmtClassForgeableFactory> .Instance)); }
private static void PlanRecursive( IList <StmtClassForgeableFactory> additionalForgeables, EventType eventType, StatementRawInfo raw, SerdeEventTypeCompileTimeRegistry registry, SerdeCompileTimeResolver resolver) { if (!registry.IsTargetHA) { return; } if (registry.EventTypes.ContainsKey(eventType)) { return; } SerdeAndForgeables pair; if (eventType is BeanEventType) { pair = PlanBean((BeanEventType)eventType, raw, resolver); } else if (eventType is BaseNestableEventType) { pair = PlanBaseNestable((BaseNestableEventType)eventType, raw, resolver); PlanPropertiesMayRecurse(eventType, additionalForgeables, raw, registry, resolver); } else if (eventType is WrapperEventType) { var wrapperEventType = (WrapperEventType)eventType; PlanRecursive(additionalForgeables, wrapperEventType.UnderlyingEventType, raw, registry, resolver); pair = PlanBaseNestable(wrapperEventType.UnderlyingMapType, raw, resolver); } else if (eventType is VariantEventType || eventType is AvroSchemaEventType || eventType is BaseXMLEventType) { // no serde generation pair = null; } else { throw new UnsupportedOperationException("Event type not yet handled: " + eventType); } if (pair != null) { registry.AddSerdeFor(eventType, pair.Forge); additionalForgeables.AddAll(pair.AdditionalForgeables); } }
private static SerdeAndForgeables PlanBaseNestable( BaseNestableEventType eventType, StatementRawInfo raw, SerdeCompileTimeResolver resolver) { string className; if (eventType is JsonEventType) { var classNameFull = ((JsonEventType)eventType).Detail.SerdeClassName; var lastDotIndex = classNameFull.LastIndexOf('.'); className = lastDotIndex == -1 ? classNameFull : classNameFull.Substring(lastDotIndex + 1); } else { var uuid = GenerateClassNameUUID(); className = GenerateClassNameWithUUID(typeof(DataInputOutputSerde), eventType.Metadata.Name, uuid); } var optionalApplicationSerde = resolver.SerdeForEventTypeExternalProvider(eventType, raw); if (optionalApplicationSerde != null) { return(new SerdeAndForgeables(optionalApplicationSerde, EmptyList <StmtClassForgeableFactory> .Instance)); } var forges = new DataInputOutputSerdeForge[eventType.Types.Count]; var count = 0; foreach (var property in eventType.Types) { var desc = ForgeForEventProperty(eventType, property.Key, property.Value, raw, resolver); forges[count] = desc.Forge; count++; } StmtClassForgeableFactory forgeable = new ProxyStmtClassForgeableFactory() { ProcMake = ( namespaceScope, classPostfix) => { return(new StmtClassForgeableBaseNestableEventTypeSerde(className, namespaceScope, eventType, forges)); }, }; var forge = new DataInputOutputSerdeForgeForClassName(className); return(new SerdeAndForgeables(forge, Collections.SingletonList(forgeable))); }
public static MultiKeyPlan PlanMultiKeyDistinct( bool isDistinct, EventType eventType, StatementRawInfo raw, SerdeCompileTimeResolver serdeResolver) { if (!isDistinct) { return(new MultiKeyPlan( EmptyList <StmtClassForgeableFactory> .Instance, MultiKeyClassRefEmpty.INSTANCE)); } string[] propertyNames = eventType.PropertyNames; Type[] props = new Type[propertyNames.Length]; for (int i = 0; i < propertyNames.Length; i++) { props[i] = eventType.GetPropertyType(propertyNames[i]); } return(PlanMultiKey(props, false, raw, serdeResolver)); }
private static void PlanPropertiesMayRecurse( EventType eventType, IList <StmtClassForgeableFactory> additionalForgeables, StatementRawInfo raw, SerdeEventTypeCompileTimeRegistry registry, SerdeCompileTimeResolver resolver) { foreach (var desc in eventType.PropertyDescriptors) { if (!desc.IsFragment) { continue; } var fragmentEventType = eventType.GetFragmentType(desc.PropertyName); if (fragmentEventType == null || registry.EventTypes.ContainsKey(fragmentEventType.FragmentType)) { continue; } PlanRecursive(additionalForgeables, fragmentEventType.FragmentType, raw, registry, resolver); } }
public static AggregationLocalGroupByPlanDesc Analyze( ExprForge[][] methodForges, AggregationForgeFactory[] methodFactories, AggregationStateFactoryForge[] accessAggregations, AggregationGroupByLocalGroupDesc localGroupDesc, ExprNode[] groupByExpressions, MultiKeyClassRef groupByMultiKey, AggregationAccessorSlotPairForge[] accessors, StatementRawInfo raw, SerdeCompileTimeResolver serdeResolver) { if (groupByExpressions == null) { groupByExpressions = ExprNodeUtilityQuery.EMPTY_EXPR_ARRAY; } var columns = new AggregationLocalGroupByColumnForge[localGroupDesc.NumColumns]; var levelsList = new List<AggregationLocalGroupByLevelForge>(); AggregationLocalGroupByLevelForge optionalTopLevel = null; var additionalForgeables = new List<StmtClassForgeableFactory>(); // determine optional top level (level number is -1) for (var i = 0; i < localGroupDesc.Levels.Length; i++) { var levelDesc = localGroupDesc.Levels[i]; if (levelDesc.PartitionExpr.Length == 0) { AggregationGroupByLocalGroupLevelDesc top = GetLevel( -1, levelDesc, methodForges, methodFactories, accessAggregations, columns, groupByExpressions.Length == 0, accessors, groupByExpressions, groupByMultiKey, raw, serdeResolver); optionalTopLevel = top.Forge; additionalForgeables.AddRange(top.AdditionalForgeables); } } // determine default (same as group-by) level, if any, assign level number 0 var levelNumber = 0; for (var i = 0; i < localGroupDesc.Levels.Length; i++) { var levelDesc = localGroupDesc.Levels[i]; if (levelDesc.PartitionExpr.Length == 0) { continue; } var isDefaultLevel = groupByExpressions != null && ExprNodeUtilityCompare.DeepEqualsIgnoreDupAndOrder( groupByExpressions, levelDesc.PartitionExpr); if (isDefaultLevel) { AggregationGroupByLocalGroupLevelDesc level = GetLevel( 0, levelDesc, methodForges, methodFactories, accessAggregations, columns, isDefaultLevel, accessors, groupByExpressions, groupByMultiKey, raw, serdeResolver); additionalForgeables.AddRange(level.AdditionalForgeables); levelsList.Add(level.Forge); levelNumber++; break; } } // determine all other levels, assign level numbers for (var i = 0; i < localGroupDesc.Levels.Length; i++) { var levelDesc = localGroupDesc.Levels[i]; if (levelDesc.PartitionExpr.Length == 0) { continue; } var isDefaultLevel = groupByExpressions != null && ExprNodeUtilityCompare.DeepEqualsIgnoreDupAndOrder( groupByExpressions, levelDesc.PartitionExpr); if (isDefaultLevel) { continue; } AggregationGroupByLocalGroupLevelDesc level = GetLevel( levelNumber, levelDesc, methodForges, methodFactories, accessAggregations, columns, isDefaultLevel, accessors, groupByExpressions, groupByMultiKey, raw, serdeResolver); levelsList.Add(level.Forge); additionalForgeables.AddRange(level.AdditionalForgeables); levelNumber++; } // totals var numMethods = 0; var numAccesses = 0; if (optionalTopLevel != null) { numMethods += optionalTopLevel.MethodFactories.Length; numAccesses += optionalTopLevel.AccessStateForges.Length; } foreach (var level in levelsList) { numMethods += level.MethodFactories.Length; numAccesses += level.AccessStateForges.Length; } AggregationLocalGroupByLevelForge[] levels = levelsList.ToArray(); AggregationLocalGroupByPlanForge forge = new AggregationLocalGroupByPlanForge(numMethods, numAccesses, columns, optionalTopLevel, levels); return new AggregationLocalGroupByPlanDesc(forge, additionalForgeables); }
// Obtain those method and state factories for each level private static AggregationGroupByLocalGroupLevelDesc GetLevel( int levelNumber, AggregationGroupByLocalGroupLevel level, ExprForge[][] methodForgesAll, AggregationForgeFactory[] methodFactoriesAll, AggregationStateFactoryForge[] accessForges, AggregationLocalGroupByColumnForge[] columns, bool defaultLevel, AggregationAccessorSlotPairForge[] accessors, ExprNode[] groupByExpressions, MultiKeyClassRef optionalGroupByMultiKey, StatementRawInfo raw, SerdeCompileTimeResolver serdeResolver) { var partitionExpr = level.PartitionExpr; MultiKeyPlan multiKeyPlan; if (defaultLevel && optionalGroupByMultiKey != null) { // use default multi-key that is already generated multiKeyPlan = new MultiKeyPlan(EmptyList<StmtClassForgeableFactory>.Instance, optionalGroupByMultiKey); partitionExpr = groupByExpressions; } else { multiKeyPlan = MultiKeyPlanner.PlanMultiKey(partitionExpr, false, raw, serdeResolver); } IList<ExprForge[]> methodForges = new List<ExprForge[]>(); IList<AggregationForgeFactory> methodFactories = new List<AggregationForgeFactory>(); IList<AggregationStateFactoryForge> stateFactories = new List<AggregationStateFactoryForge>(); foreach (var expr in level.Expressions) { int column = expr.AggregationNode.Column; var methodOffset = -1; var methodAgg = true; AggregationAccessorSlotPairForge pair = null; if (column < methodForgesAll.Length) { methodForges.Add(methodForgesAll[column]); methodFactories.Add(methodFactoriesAll[column]); methodOffset = methodFactories.Count - 1; } else { // slot gives us the number of the state factory int absoluteSlot = accessors[column - methodForgesAll.Length].Slot; AggregationAccessorForge accessor = accessors[column - methodForgesAll.Length].AccessorForge; var factory = accessForges[absoluteSlot]; var relativeSlot = stateFactories.IndexOf(factory); if (relativeSlot == -1) { stateFactories.Add(factory); relativeSlot = stateFactories.Count - 1; } methodAgg = false; pair = new AggregationAccessorSlotPairForge(relativeSlot, accessor); } columns[column] = new AggregationLocalGroupByColumnForge( defaultLevel, partitionExpr, methodOffset, methodAgg, pair, levelNumber); } var forge = new AggregationLocalGroupByLevelForge( methodForges.ToArray(), methodFactories.ToArray(), stateFactories.ToArray(), partitionExpr, multiKeyPlan.ClassRef, defaultLevel); // NOTE: The original code tests for multiKeyPlan being null, but if it was null it would have caused // a null pointer exception on the previous statement since it dereferences ClassRef. var additionalForgeables = multiKeyPlan?.MultiKeyForgeables ?? EmptyList<StmtClassForgeableFactory>.Instance; return new AggregationGroupByLocalGroupLevelDesc(forge, additionalForgeables); }
/// <summary> /// Create the table lookup plan for a from-stream to look up in an indexed stream /// using the columns supplied in the query graph and looking at the actual indexes available /// and their index number. /// </summary> /// <param name="queryGraph">contains properties joining the 2 streams</param> /// <param name="currentLookupStream">stream to use key values from</param> /// <param name="indexedStream">stream to look up in</param> /// <param name="indexSpecs">index specification defining indexes to be created for stream</param> /// <param name="typesPerStream">event types for each stream</param> /// <param name="indexedStreamTableMeta">table info</param> /// <param name="indexedStreamIsVDW">vdw indicators</param> /// <param name="raw">raw statement information</param> /// <param name="serdeResolver">serde resolver</param> /// <returns>plan for performing a lookup in a given table using one of the indexes supplied</returns> public static TableLookupPlanDesc CreateLookupPlan( QueryGraphForge queryGraph, int currentLookupStream, int indexedStream, bool indexedStreamIsVDW, QueryPlanIndexForge indexSpecs, EventType[] typesPerStream, TableMetaData indexedStreamTableMeta, StatementRawInfo raw, SerdeCompileTimeResolver serdeResolver) { var queryGraphValue = queryGraph.GetGraphValue(currentLookupStream, indexedStream); var hashKeyProps = queryGraphValue.HashKeyProps; var hashPropsKeys = hashKeyProps.Keys; var hashIndexProps = hashKeyProps.Indexed; var rangeProps = queryGraphValue.RangeProps; var rangePropsKeys = rangeProps.Keys; var rangeIndexProps = rangeProps.Indexed; var pairIndexHashRewrite = indexSpecs.GetIndexNum(hashIndexProps, rangeIndexProps); var indexNum = pairIndexHashRewrite == null ? null : pairIndexHashRewrite.First; // handle index redirection towards unique index if (pairIndexHashRewrite != null && pairIndexHashRewrite.Second != null) { var indexes = pairIndexHashRewrite.Second; var newHashIndexProps = new string[indexes.Length]; IList<QueryGraphValueEntryHashKeyedForge> newHashKeys = new List<QueryGraphValueEntryHashKeyedForge>(); for (var i = 0; i < indexes.Length; i++) { newHashIndexProps[i] = hashIndexProps[indexes[i]]; newHashKeys.Add(hashPropsKeys[indexes[i]]); } hashIndexProps = newHashIndexProps; hashPropsKeys = newHashKeys; rangeIndexProps = new string[0]; rangePropsKeys = Collections.GetEmptyList<QueryGraphValueEntryRangeForge>(); } // no direct hash or range lookups if (hashIndexProps.Length == 0 && rangeIndexProps.Length == 0) { // handle single-direction 'in' keyword var singles = queryGraphValue.InKeywordSingles; if (!singles.Key.IsEmpty()) { QueryGraphValueEntryInKeywordSingleIdxForge single = null; indexNum = null; if (indexedStreamTableMeta != null) { var indexes = singles.Indexed; var count = 0; foreach (var index in indexes) { var indexPairFound = EventTableIndexUtil.FindIndexBestAvailable( indexedStreamTableMeta.IndexMetadata.Indexes, Collections.SingletonSet(index), Collections.GetEmptySet<string>(), null); if (indexPairFound != null) { indexNum = new TableLookupIndexReqKey( indexPairFound.Second.OptionalIndexName, indexPairFound.Second.OptionalIndexModuleName, indexedStreamTableMeta.TableName); single = singles.Key[count]; } count++; } } else { single = singles.Key[0]; var pairIndex = indexSpecs.GetIndexNum( new[] {singles.Indexed[0]}, new string[0]); indexNum = pairIndex.First; } if (indexNum != null) { var forge = new InKeywordTableLookupPlanSingleIdxForge( currentLookupStream, indexedStream, indexedStreamIsVDW, typesPerStream, indexNum, single.KeyExprs); return new TableLookupPlanDesc(forge, EmptyList<StmtClassForgeableFactory>.Instance); } } // handle multi-direction 'in' keyword var multis = queryGraphValue.InKeywordMulti; if (!multis.IsEmpty()) { if (indexedStreamTableMeta != null) { return GetFullTableScanTable( currentLookupStream, indexedStream, indexedStreamIsVDW, typesPerStream, indexedStreamTableMeta); } var multi = multis[0]; var indexNameArray = new TableLookupIndexReqKey[multi.Indexed.Length]; var foundAll = true; for (var i = 0; i < multi.Indexed.Length; i++) { var identNode = (ExprIdentNode) multi.Indexed[i]; var pairIndex = indexSpecs.GetIndexNum( new[] {identNode.ResolvedPropertyName}, new string[0]); if (pairIndex == null) { foundAll = false; } else { indexNameArray[i] = pairIndex.First; } } if (foundAll) { var forge = new InKeywordTableLookupPlanMultiIdxForge( currentLookupStream, indexedStream, indexedStreamIsVDW, typesPerStream, indexNameArray, multi.Key.KeyExpr); return new TableLookupPlanDesc(forge, EmptyList<StmtClassForgeableFactory>.Instance); } } // We don't use a keyed index but use the full stream set as the stream does not have any indexes // If no such full set index exists yet, add to specs if (indexedStreamTableMeta != null) { return GetFullTableScanTable( currentLookupStream, indexedStream, indexedStreamIsVDW, typesPerStream, indexedStreamTableMeta); } if (indexNum == null) { indexNum = new TableLookupIndexReqKey( indexSpecs.AddIndex(new string[0], new Type[0], typesPerStream[indexedStream]), null); } var forgeX = new FullTableScanLookupPlanForge(currentLookupStream, indexedStream, indexedStreamIsVDW, typesPerStream, indexNum); return new TableLookupPlanDesc(forgeX, EmptyList<StmtClassForgeableFactory>.Instance); } if (indexNum == null) { throw new IllegalStateException( "Failed to query plan as index for " + hashIndexProps.RenderAny() + " and " + rangeIndexProps.RenderAny() + " in the index specification"); } if (indexedStreamTableMeta != null) { var indexPairFound = EventTableIndexUtil.FindIndexBestAvailable( indexedStreamTableMeta.IndexMetadata.Indexes, ToSet(hashIndexProps), ToSet(rangeIndexProps), null); if (indexPairFound != null) { var indexKeyInfo = SubordinateQueryPlannerUtil.CompileIndexKeyInfo( indexPairFound.First, hashIndexProps, GetHashKeyFuncsAsSubProp(hashPropsKeys), rangeIndexProps, GetRangeFuncsAsSubProp(rangePropsKeys)); if (indexKeyInfo.OrderedKeyCoercionTypes.IsCoerce || indexKeyInfo.OrderedRangeCoercionTypes.IsCoerce) { return GetFullTableScanTable( currentLookupStream, indexedStream, indexedStreamIsVDW, typesPerStream, indexedStreamTableMeta); } hashPropsKeys = ToHashKeyFuncs(indexKeyInfo.OrderedHashDesc); hashIndexProps = IndexedPropDesc.GetIndexProperties(indexPairFound.First.HashIndexedProps); rangePropsKeys = ToRangeKeyFuncs(indexKeyInfo.OrderedRangeDesc); rangeIndexProps = IndexedPropDesc.GetIndexProperties(indexPairFound.First.RangeIndexedProps); indexNum = new TableLookupIndexReqKey( indexPairFound.Second.OptionalIndexName, indexPairFound.Second.OptionalIndexModuleName, indexedStreamTableMeta.TableName); // the plan will be created below if (hashIndexProps.Length == 0 && rangeIndexProps.Length == 0) { return GetFullTableScanTable( currentLookupStream, indexedStream, indexedStreamIsVDW, typesPerStream, indexedStreamTableMeta); } } else { return GetFullTableScanTable( currentLookupStream, indexedStream, indexedStreamIsVDW, typesPerStream, indexedStreamTableMeta); } } // straight keyed-index lookup if (hashIndexProps.Length > 0 && rangeIndexProps.Length == 0) { // Determine coercion required var coercionTypes = CoercionUtil.GetCoercionTypesHash( typesPerStream, currentLookupStream, indexedStream, hashPropsKeys, hashIndexProps); if (coercionTypes.IsCoerce) { // check if there already are coercion types for this index var existCoercionTypes = indexSpecs.GetCoercionTypes(hashIndexProps); if (existCoercionTypes != null) { for (var i = 0; i < existCoercionTypes.Length; i++) { coercionTypes.CoercionTypes[i] = existCoercionTypes[i] .GetCompareToCoercionType(coercionTypes.CoercionTypes[i]); } } if (!indexSpecs.Items.IsEmpty()) { indexSpecs.SetCoercionTypes(hashIndexProps, coercionTypes.CoercionTypes); } } var coercionTypesArray = coercionTypes.CoercionTypes; MultiKeyClassRef tableLookupMultiKey = null; IList<StmtClassForgeableFactory> additionalForgeables = EmptyList<StmtClassForgeableFactory>.Instance; if (indexNum.TableName != null) { var tableMultiKeyPlan = MultiKeyPlanner.PlanMultiKey(coercionTypesArray, true, raw, serdeResolver); tableLookupMultiKey = tableMultiKeyPlan.ClassRef; additionalForgeables = tableMultiKeyPlan.MultiKeyForgeables; } var forge = new IndexedTableLookupPlanHashedOnlyForge( currentLookupStream, indexedStream, indexedStreamIsVDW, typesPerStream, indexNum, hashPropsKeys.ToArray(), indexSpecs, coercionTypesArray, tableLookupMultiKey); return new TableLookupPlanDesc(forge, additionalForgeables); } // sorted index lookup var coercionTypesRange = CoercionUtil.GetCoercionTypesRange( typesPerStream, indexedStream, rangeIndexProps, rangePropsKeys); var coercionTypesHash = CoercionUtil.GetCoercionTypesHash( typesPerStream, currentLookupStream, indexedStream, hashPropsKeys, hashIndexProps); if (hashIndexProps.Length == 0 && rangeIndexProps.Length == 1) { var range = rangePropsKeys[0]; Type coercionType = null; if (coercionTypesRange.IsCoerce) { coercionType = coercionTypesRange.CoercionTypes[0]; } SortedTableLookupPlanForge forge = new SortedTableLookupPlanForge( currentLookupStream, indexedStream, indexedStreamIsVDW, typesPerStream, indexNum, range, coercionType); return new TableLookupPlanDesc(forge, EmptyList<StmtClassForgeableFactory>.Instance); } else { MultiKeyClassRef tableLookupMultiKey = null; IList<StmtClassForgeableFactory> additionalForgeables = EmptyList<StmtClassForgeableFactory>.Instance; if (indexNum.TableName != null) { MultiKeyPlan tableMultiKeyPlan = MultiKeyPlanner.PlanMultiKey(coercionTypesHash.CoercionTypes, true, raw, serdeResolver); tableLookupMultiKey = tableMultiKeyPlan.ClassRef; additionalForgeables = tableMultiKeyPlan.MultiKeyForgeables; } // composite range and index lookup CompositeTableLookupPlanForge forge = new CompositeTableLookupPlanForge( currentLookupStream, indexedStream, indexedStreamIsVDW, typesPerStream, indexNum, hashPropsKeys, coercionTypesHash.CoercionTypes, rangePropsKeys, coercionTypesRange.CoercionTypes, indexSpecs, tableLookupMultiKey); return new TableLookupPlanDesc(forge, additionalForgeables); } }
public static QueryPlanForgeDesc Build( QueryGraphForge queryGraph, EventType[] typesPerStream, HistoricalViewableDesc historicalViewableDesc, DependencyGraph dependencyGraph, HistoricalStreamIndexListForge[] historicalStreamIndexLists, bool hasForceNestedIter, string[][][] indexedStreamsUniqueProps, TableMetaData[] tablesPerStream, StreamJoinAnalysisResultCompileTime streamJoinAnalysisResult, StatementRawInfo raw, SerdeCompileTimeResolver serdeResolver) { if (Log.IsDebugEnabled) { Log.Debug(".build filterQueryGraph=" + queryGraph); } var numStreams = queryGraph.NumStreams; var additionalForgeables = new List<StmtClassForgeableFactory>(); var indexSpecs = QueryPlanIndexBuilder.BuildIndexSpec( queryGraph, typesPerStream, indexedStreamsUniqueProps); if (Log.IsDebugEnabled) { Log.Debug(".build Index build completed, indexes=" + QueryPlanIndexForge.Print(indexSpecs)); } // any historical streams don't get indexes, the lookup strategy accounts for cached indexes if (historicalViewableDesc.IsHistorical) { for (var i = 0; i < historicalViewableDesc.Historical.Length; i++) { if (historicalViewableDesc.Historical[i]) { indexSpecs[i] = null; } } } var planNodeSpecs = new QueryPlanNodeForge[numStreams]; var worstDepth = int.MaxValue; for (var streamNo = 0; streamNo < numStreams; streamNo++) { // no plan for historical streams that are dependent upon other streams if (historicalViewableDesc.Historical[streamNo] && dependencyGraph.HasDependency(streamNo)) { planNodeSpecs[streamNo] = new QueryPlanNodeNoOpForge(); continue; } var bestChainResult = ComputeBestPath(streamNo, queryGraph, dependencyGraph); var bestChain = bestChainResult.Chain; if (Log.IsDebugEnabled) { Log.Debug(".build For stream " + streamNo + " bestChain=" + bestChain.RenderAny()); } if (bestChainResult.Depth < worstDepth) { worstDepth = bestChainResult.Depth; } var planDesc = CreateStreamPlan( streamNo, bestChain, queryGraph, indexSpecs, typesPerStream, historicalViewableDesc.Historical, historicalStreamIndexLists, tablesPerStream, streamJoinAnalysisResult, raw, serdeResolver); planNodeSpecs[streamNo] = planDesc.Forge; additionalForgeables.AddAll(planDesc.AdditionalForgeables); if (Log.IsDebugEnabled) { Log.Debug(".build spec=" + planNodeSpecs[streamNo]); } } // We use the merge/nested (outer) join algorithm instead. if (worstDepth < numStreams - 1 && !hasForceNestedIter) { return null; } // build historical index and lookup strategies for (var i = 0; i < numStreams; i++) { var plan = planNodeSpecs[i]; QueryPlanNodeForgeVisitor visitor = new ProxyQueryPlanNodeForgeVisitor { ProcVisit = node => { if (node is HistoricalDataPlanNodeForge) { var historical = (HistoricalDataPlanNodeForge) node; JoinSetComposerPrototypeHistoricalDesc desc = historicalStreamIndexLists[historical.StreamNum].GetStrategy( historical.LookupStreamNum, raw, serdeResolver); historical.PollResultIndexingStrategy = desc.IndexingForge; historical.HistoricalIndexLookupStrategy = desc.LookupForge; additionalForgeables.AddAll(desc.AdditionalForgeables); } } }; plan.Accept(visitor); } var forge = new QueryPlanForge(indexSpecs, planNodeSpecs); return new QueryPlanForgeDesc(forge, additionalForgeables); }
/// <summary> /// Constructs indexing and lookup strategy for a given relationship that a historical stream may have with another /// stream (historical or not) that looks up into results of a poll of a historical stream. /// <para /> /// The term "polled" refers to the assumed-historical stream. /// </summary> /// <param name="queryGraph">relationship representation of where-clause filter and outer join on-expressions</param> /// <param name="polledViewType">the event type of the historical that is indexed</param> /// <param name="streamViewType">the event type of the stream looking up in indexes</param> /// <param name="polledViewStreamNum">the stream number of the historical that is indexed</param> /// <param name="streamViewStreamNum">the stream number of the historical that is looking up</param> /// <param name="raw"></param> /// <param name="serdeResolver"></param> /// <returns>indexing and lookup strategy pair</returns> public static JoinSetComposerPrototypeHistoricalDesc DetermineIndexing( QueryGraphForge queryGraph, EventType polledViewType, EventType streamViewType, int polledViewStreamNum, int streamViewStreamNum, StatementRawInfo raw, SerdeCompileTimeResolver serdeResolver) { var queryGraphValue = queryGraph.GetGraphValue(streamViewStreamNum, polledViewStreamNum); var hashKeysAndIndes = queryGraphValue.HashKeyProps; var rangeKeysAndIndex = queryGraphValue.RangeProps; // index and key property names var hashKeys = hashKeysAndIndes.Keys; var hashIndexes = hashKeysAndIndes.Indexed; var rangeKeys = rangeKeysAndIndex.Keys; var rangeIndexes = rangeKeysAndIndex.Indexed; // If the analysis revealed no join columns, must use the brute-force full table scan if (hashKeys.IsEmpty() && rangeKeys.IsEmpty()) { var inKeywordSingles = queryGraphValue.InKeywordSingles; if (inKeywordSingles != null && inKeywordSingles.Indexed.Length != 0) { var indexed = inKeywordSingles.Indexed[0]; var lookup = inKeywordSingles.Key[0]; var strategy = new HistoricalIndexLookupStrategyInKeywordSingleForge(streamViewStreamNum, lookup.KeyExprs); var indexing = new PollResultIndexingStrategyHashForge( polledViewStreamNum, polledViewType, new string[]{ indexed }, null, null); return new JoinSetComposerPrototypeHistoricalDesc(strategy, indexing, EmptyList<StmtClassForgeableFactory>.Instance); } var multis = queryGraphValue.InKeywordMulti; if (!multis.IsEmpty()) { var multi = multis[0]; var strategy = new HistoricalIndexLookupStrategyInKeywordMultiForge(streamViewStreamNum, multi.Key.KeyExpr); var indexing = new PollResultIndexingStrategyInKeywordMultiForge( polledViewStreamNum, polledViewType, ExprNodeUtilityQuery.GetIdentResolvedPropertyNames(multi.Indexed)); return new JoinSetComposerPrototypeHistoricalDesc(strategy, indexing, EmptyList<StmtClassForgeableFactory>.Instance); } return new JoinSetComposerPrototypeHistoricalDesc( HistoricalIndexLookupStrategyNoIndexForge.INSTANCE, PollResultIndexingStrategyNoIndexForge.INSTANCE, EmptyList<StmtClassForgeableFactory>.Instance); } CoercionDesc keyCoercionTypes = CoercionUtil.GetCoercionTypesHash( new[] {streamViewType, polledViewType}, 0, 1, hashKeys, hashIndexes); if (rangeKeys.IsEmpty()) { var hashEvals = QueryGraphValueEntryHashKeyedForge.GetForges(hashKeys.ToArray()); var multiKeyPlan = MultiKeyPlanner.PlanMultiKey(hashEvals, false, raw, serdeResolver); var lookup = new HistoricalIndexLookupStrategyHashForge( streamViewStreamNum, hashEvals, keyCoercionTypes.CoercionTypes, multiKeyPlan.ClassRef); var indexing = new PollResultIndexingStrategyHashForge( polledViewStreamNum, polledViewType, hashIndexes, keyCoercionTypes.CoercionTypes, multiKeyPlan.ClassRef); return new JoinSetComposerPrototypeHistoricalDesc(lookup, indexing, multiKeyPlan.MultiKeyForgeables); } CoercionDesc rangeCoercionTypes = CoercionUtil.GetCoercionTypesRange( new[] {streamViewType, polledViewType}, 1, rangeIndexes, rangeKeys); if (rangeKeys.Count == 1 && hashKeys.Count == 0) { var rangeCoercionType = rangeCoercionTypes.CoercionTypes[0]; var indexing = new PollResultIndexingStrategySortedForge( polledViewStreamNum, polledViewType, rangeIndexes[0], rangeCoercionType); var lookup = new HistoricalIndexLookupStrategySortedForge( streamViewStreamNum, rangeKeys[0], rangeCoercionType); return new JoinSetComposerPrototypeHistoricalDesc(lookup, indexing, EmptyList<StmtClassForgeableFactory>.Instance); } else { var hashEvals = QueryGraphValueEntryHashKeyedForge.GetForges(hashKeys.ToArray()); var multiKeyPlan = MultiKeyPlanner.PlanMultiKey(hashEvals, false, raw, serdeResolver); var strategy = new HistoricalIndexLookupStrategyCompositeForge( streamViewStreamNum, hashEvals, multiKeyPlan.ClassRef, rangeKeys.ToArray()); var indexing = new PollResultIndexingStrategyCompositeForge( polledViewStreamNum, polledViewType, hashIndexes, keyCoercionTypes.CoercionTypes, multiKeyPlan.ClassRef, rangeIndexes, rangeCoercionTypes.CoercionTypes); return new JoinSetComposerPrototypeHistoricalDesc(strategy, indexing, multiKeyPlan.MultiKeyForgeables); } }
public static SerdeEventPropertyDesc ForgeForEventProperty( EventType eventTypeSerde, string propertyName, object propertyType, StatementRawInfo raw, SerdeCompileTimeResolver resolver) { DataInputOutputSerdeForge forge; if (propertyType == null) { return(new SerdeEventPropertyDesc(new DataInputOutputSerdeForgeSingleton(typeof(DIOSkipSerde)), EmptySet <EventType> .Instance)); } if (propertyType is Type propertyTypeType) { // handle special Json catch-all types if (eventTypeSerde is JsonEventType) { forge = null; if (propertyTypeType == typeof(IDictionary <string, object>)) { forge = new DataInputOutputSerdeForgeSingleton(typeof(DIOJsonObjectSerde)); } else if (propertyTypeType == typeof(object[])) { forge = new DataInputOutputSerdeForgeSingleton(typeof(DIOJsonArraySerde)); } else if (propertyTypeType == typeof(object)) { forge = new DataInputOutputSerdeForgeSingleton(typeof(DIOJsonAnyValueSerde)); } if (forge != null) { return(new SerdeEventPropertyDesc(forge, EmptySet <EventType> .Instance)); } } // handle all Class-type properties var typedProperty = (Type)propertyType; if (typedProperty == typeof(object) && propertyName.Equals(INTERNAL_RESERVED_PROPERTY)) { forge = new DataInputOutputSerdeForgeSingleton( typeof(DIOSkipSerde)); // for expression data window or others that include transient references in the field } else { forge = resolver.SerdeForEventProperty(typedProperty, eventTypeSerde.Name, propertyName, raw); } return(new SerdeEventPropertyDesc(forge, EmptySet <EventType> .Instance)); } if (propertyType is EventType) { var eventType = (EventType)propertyType; Func <DataInputOutputSerdeForgeParameterizedVars, CodegenExpression> func = vars => ResolveTypeCodegenGivenResolver(eventType, vars.OptionalEventTypeResolver); forge = new DataInputOutputSerdeForgeEventSerde("NullableEvent", func); return(new SerdeEventPropertyDesc(forge, Collections.SingletonSet(eventType))); } else if (propertyType is EventType[]) { var eventType = ((EventType[])propertyType)[0]; Func <DataInputOutputSerdeForgeParameterizedVars, CodegenExpression> func = vars => ResolveTypeCodegenGivenResolver(eventType, vars.OptionalEventTypeResolver); forge = new DataInputOutputSerdeForgeEventSerde("NullableEventArray", func); return(new SerdeEventPropertyDesc(forge, Collections.SingletonSet(eventType))); } else if (propertyType is TypeBeanOrUnderlying) { var eventType = ((TypeBeanOrUnderlying)propertyType).EventType; Func <DataInputOutputSerdeForgeParameterizedVars, CodegenExpression> func = vars => ResolveTypeCodegenGivenResolver(eventType, vars.OptionalEventTypeResolver); forge = new DataInputOutputSerdeForgeEventSerde("NullableEventOrUnderlying", func); return(new SerdeEventPropertyDesc(forge, Collections.SingletonSet(eventType))); } else if (propertyType is TypeBeanOrUnderlying[]) { var eventType = ((TypeBeanOrUnderlying[])propertyType)[0].EventType; Func <DataInputOutputSerdeForgeParameterizedVars, CodegenExpression> func = vars => ResolveTypeCodegenGivenResolver(eventType, vars.OptionalEventTypeResolver); forge = new DataInputOutputSerdeForgeEventSerde("NullableEventArrayOrUnderlying", func); return(new SerdeEventPropertyDesc(forge, Collections.SingletonSet(eventType))); } else if (propertyType is IDictionary <string, object> keyValueProperties) { var keys = new string[keyValueProperties.Count]; var serdes = new DataInputOutputSerdeForge[keyValueProperties.Count]; var index = 0; var nestedTypes = new LinkedHashSet <EventType>(); // Rewrite all properties where the value is a string. First, gather all instances that need // to be rewritten into the class that matches the type. keyValueProperties .Where(entry => entry.Value is string) .ToList() .ForEach( entry => { var value = entry.Value.ToString()?.Trim(); var clazz = TypeHelper.GetPrimitiveTypeForName(value); if (clazz != null) { keyValueProperties[entry.Key] = clazz; } }); foreach (var entry in keyValueProperties) { keys[index] = entry.Key; var desc = ForgeForEventProperty(eventTypeSerde, entry.Key, entry.Value, raw, resolver); nestedTypes.AddAll(desc.NestedTypes); serdes[index] = desc.Forge; index++; } var functions = new Func <DataInputOutputSerdeForgeParameterizedVars, CodegenExpression> [2]; functions[0] = vars => Constant(keys); functions[1] = vars => DataInputOutputSerdeForgeExtensions.CodegenArray(serdes, vars.Method, vars.Scope, vars.OptionalEventTypeResolver); forge = new DataInputOutputSerdeForgeParameterized(typeof(DIOMapPropertySerde).Name, functions); return(new SerdeEventPropertyDesc(forge, nestedTypes)); } else { throw new EPException( "Failed to determine serde for unrecognized property value type '" + propertyType + "' for property '" + propertyName + "' of type '" + eventTypeSerde.Name + "'"); } }
public static MultiKeyPlan PlanMultiKey( Type[] types, bool lenientEquals, StatementRawInfo raw, SerdeCompileTimeResolver serdeResolver) { if (types == null || types.Length == 0) { return(new MultiKeyPlan( EmptyList <StmtClassForgeableFactory> .Instance, MultiKeyClassRefEmpty.INSTANCE)); } if (types.Length == 1) { Type paramType = types[0]; if (paramType == null || !paramType.IsArray) { DataInputOutputSerdeForge serdeForge = serdeResolver.SerdeForKeyNonArray(paramType, raw); return(new MultiKeyPlan( EmptyList <StmtClassForgeableFactory> .Instance, new MultiKeyClassRefWSerde(serdeForge, types))); } Type mkClass = GetMKClassForComponentType(paramType.GetElementType()); DataInputOutputSerde mkSerde = GetMKSerdeClassForComponentType(paramType.GetElementType()); return(new MultiKeyPlan( EmptyList <StmtClassForgeableFactory> .Instance, new MultiKeyClassRefPredetermined( mkClass, types, new DataInputOutputSerdeForgeSingleton(mkSerde.GetType())))); } Type[] boxed = new Type[types.Length]; for (int i = 0; i < boxed.Length; i++) { boxed[i] = Boxing.GetBoxedType(types[i]); } MultiKeyClassRefUUIDBased classNames = new MultiKeyClassRefUUIDBased(boxed); StmtClassForgeableFactory factoryMK = new ProxyStmtClassForgeableFactory( ( namespaceScope, classPostfix) => { return(new StmtClassForgeableMultiKey(classNames.GetClassNameMK(classPostfix), namespaceScope, types, lenientEquals)); }); DataInputOutputSerdeForge[] forges = serdeResolver.SerdeForMultiKey(types, raw); StmtClassForgeableFactory factoryMKSerde = new ProxyStmtClassForgeableFactory( ( namespaceScope, classPostfix) => { return(new StmtClassForgeableMultiKeySerde( classNames.GetClassNameMKSerde(classPostfix), namespaceScope, types, classNames.GetClassNameMK(classPostfix), forges)); }); IList <StmtClassForgeableFactory> forgeables = Arrays.AsList(factoryMK, factoryMKSerde); return(new MultiKeyPlan(forgeables, classNames)); }
public ModuleCompileTimeServices( IContainer container, CompilerServices compilerServices, Configuration configuration, ContextCompileTimeRegistry contextCompileTimeRegistry, ContextCompileTimeResolver contextCompileTimeResolver, BeanEventTypeStemService beanEventTypeStemService, BeanEventTypeFactoryPrivate beanEventTypeFactoryPrivate, ClassProvidedCompileTimeRegistry classProvidedCompileTimeRegistry, ClassProvidedCompileTimeResolver classProvidedCompileTimeResolver, DatabaseConfigServiceCompileTime databaseConfigServiceCompileTime, ImportServiceCompileTime importService, ExprDeclaredCompileTimeRegistry exprDeclaredCompileTimeRegistry, ExprDeclaredCompileTimeResolver exprDeclaredCompileTimeResolver, EventTypeAvroHandler eventTypeAvroHandler, EventTypeCompileTimeRegistry eventTypeCompileTimeRegistry, EventTypeCompileTimeResolver eventTypeCompileTimeResolver, EventTypeRepositoryImpl eventTypeRepositoryPreconfigured, bool fireAndForget, IndexCompileTimeRegistry indexCompileTimeRegistry, ModuleDependenciesCompileTime moduleDependencies, ModuleAccessModifierService moduleVisibilityRules, NamedWindowCompileTimeResolver namedWindowCompileTimeResolver, NamedWindowCompileTimeRegistry namedWindowCompileTimeRegistry, ParentClassLoader parentClassLoader, PatternObjectResolutionService patternObjectResolutionService, ScriptCompileTimeRegistry scriptCompileTimeRegistry, ScriptCompileTimeResolver scriptCompileTimeResolver, ScriptCompiler scriptCompiler, SerdeEventTypeCompileTimeRegistry serdeEventTypeRegistry, SerdeCompileTimeResolver serdeResolver, TableCompileTimeRegistry tableCompileTimeRegistry, TableCompileTimeResolver tableCompileTimeResolver, VariableCompileTimeRegistry variableCompileTimeRegistry, VariableCompileTimeResolver variableCompileTimeResolver, ViewResolutionService viewResolutionService, XMLFragmentEventTypeFactory xmlFragmentEventTypeFactory) { var generation = Interlocked.Increment(ref _generation); Namespace = $"generation_{generation}"; Container = container; CompilerServices = compilerServices; Configuration = configuration; ContextCompileTimeRegistry = contextCompileTimeRegistry; ContextCompileTimeResolver = contextCompileTimeResolver; BeanEventTypeStemService = beanEventTypeStemService; BeanEventTypeFactoryPrivate = beanEventTypeFactoryPrivate; DatabaseConfigServiceCompileTime = databaseConfigServiceCompileTime; ImportServiceCompileTime = importService; ExprDeclaredCompileTimeRegistry = exprDeclaredCompileTimeRegistry; ExprDeclaredCompileTimeResolver = exprDeclaredCompileTimeResolver; EventTypeAvroHandler = eventTypeAvroHandler; EventTypeCompileTimeRegistry = eventTypeCompileTimeRegistry; EventTypeCompileTimeResolver = eventTypeCompileTimeResolver; EventTypeRepositoryPreconfigured = eventTypeRepositoryPreconfigured; IndexCompileTimeRegistry = indexCompileTimeRegistry; ModuleDependencies = moduleDependencies; ModuleVisibilityRules = moduleVisibilityRules; NamedWindowCompileTimeResolver = namedWindowCompileTimeResolver; NamedWindowCompileTimeRegistry = namedWindowCompileTimeRegistry; ParentClassLoader = parentClassLoader; PatternObjectResolutionService = patternObjectResolutionService; ScriptCompileTimeRegistry = scriptCompileTimeRegistry; ScriptCompileTimeResolver = scriptCompileTimeResolver; ScriptCompiler = scriptCompiler; TableCompileTimeRegistry = tableCompileTimeRegistry; TableCompileTimeResolver = tableCompileTimeResolver; VariableCompileTimeRegistry = variableCompileTimeRegistry; VariableCompileTimeResolver = variableCompileTimeResolver; ViewResolutionService = viewResolutionService; XmlFragmentEventTypeFactory = xmlFragmentEventTypeFactory; #region ESPER_8.5.1 ClassProvidedCompileTimeRegistry = classProvidedCompileTimeRegistry; ClassProvidedCompileTimeResolver = classProvidedCompileTimeResolver; SerdeEventTypeRegistry = serdeEventTypeRegistry; SerdeResolver = serdeResolver; IsFireAndForget = fireAndForget; #endregion }
/// <summary> /// Get the strategies to use for polling from a given stream. /// </summary> /// <param name="streamViewStreamNum">the stream providing the polling events</param> /// <returns>looking and indexing strategy</returns> public JoinSetComposerPrototypeHistoricalDesc GetStrategy( int streamViewStreamNum, StatementRawInfo raw, SerdeCompileTimeResolver serdeResolver) { // If there is only a single polling stream, then build a single index if (_pollingStreams.Count == 1) { return JoinSetComposerPrototypeForgeFactory.DetermineIndexing( _queryGraph, _typesPerStream[_historicalStreamNum], _typesPerStream[streamViewStreamNum], _historicalStreamNum, streamViewStreamNum, raw, serdeResolver); } // If there are multiple polling streams, determine if a single index is appropriate. // An index can be reused if: // (a) indexed property names are the same // (b) indexed property types are the same // (c) key property types are the same (because of coercion) // A index lookup strategy is always specific to the providing stream. var additionalForgeables = new List<StmtClassForgeableFactory>(); if (_indexesUsedByStreams == null) { _indexesUsedByStreams = new LinkedHashMap<HistoricalStreamIndexDesc, IList<int>>(); foreach (var pollingStream in _pollingStreams) { var queryGraphValue = _queryGraph.GetGraphValue(pollingStream, _historicalStreamNum); var hashKeyProps = queryGraphValue.HashKeyProps; var indexProperties = hashKeyProps.Indexed; var keyTypes = GetPropertyTypes(hashKeyProps.Keys); var indexTypes = GetPropertyTypes(_typesPerStream[_historicalStreamNum], indexProperties); var desc = new HistoricalStreamIndexDesc( indexProperties, indexTypes, keyTypes); var usedByStreams = _indexesUsedByStreams.Get(desc); if (usedByStreams == null) { usedByStreams = new List<int>(); _indexesUsedByStreams.Put(desc, usedByStreams); } usedByStreams.Add(pollingStream); } // There are multiple indexes required: // Build a master indexing strategy that forms multiple indexes and numbers each. if (_indexesUsedByStreams.Count > 1) { var numIndexes = _indexesUsedByStreams.Count; var indexingStrategies = new PollResultIndexingStrategyForge[numIndexes]; // create an indexing strategy for each index var count = 0; foreach (var desc in _indexesUsedByStreams) { var sampleStreamViewStreamNum = desc.Value[0]; var indexingX = JoinSetComposerPrototypeForgeFactory.DetermineIndexing( _queryGraph, _typesPerStream[_historicalStreamNum], _typesPerStream[sampleStreamViewStreamNum], _historicalStreamNum, sampleStreamViewStreamNum, raw, serdeResolver); indexingStrategies[count] = indexingX.IndexingForge; additionalForgeables.AddAll(indexingX.AdditionalForgeables); count++; } // create a master indexing strategy that utilizes each indexing strategy to create a set of indexes _masterIndexingStrategy = new PollResultIndexingStrategyMultiForge( streamViewStreamNum, indexingStrategies); } } // there is one type of index if (_indexesUsedByStreams.Count == 1) { return JoinSetComposerPrototypeForgeFactory.DetermineIndexing( _queryGraph, _typesPerStream[_historicalStreamNum], _typesPerStream[streamViewStreamNum], _historicalStreamNum, streamViewStreamNum, raw, serdeResolver); } // determine which index number the polling stream must use var indexUsed = 0; var found = false; foreach (var desc in _indexesUsedByStreams.Values) { if (desc.Contains(streamViewStreamNum)) { found = true; break; } indexUsed++; } if (!found) { throw new IllegalStateException("Index not found for use by stream " + streamViewStreamNum); } // Use one of the indexes built by the master index and a lookup strategy JoinSetComposerPrototypeHistoricalDesc indexing = JoinSetComposerPrototypeForgeFactory.DetermineIndexing( _queryGraph, _typesPerStream[_historicalStreamNum], _typesPerStream[streamViewStreamNum], _historicalStreamNum, streamViewStreamNum, raw, serdeResolver); HistoricalIndexLookupStrategyForge innerLookupStrategy = indexing.LookupForge; HistoricalIndexLookupStrategyForge lookupStrategy = new HistoricalIndexLookupStrategyMultiForge(indexUsed, innerLookupStrategy); additionalForgeables.AddAll(indexing.AdditionalForgeables); return new JoinSetComposerPrototypeHistoricalDesc(lookupStrategy, _masterIndexingStrategy, additionalForgeables); }
public static AggregationServiceForgeDesc GetService( IList<ExprAggregateNode> selectAggregateExprNodes, IDictionary<ExprNode, string> selectClauseNamedNodes, IList<ExprDeclaredNode> declaredExpressions, ExprNode[] groupByNodes, MultiKeyClassRef groupByMultiKey, IList<ExprAggregateNode> havingAggregateExprNodes, IList<ExprAggregateNode> orderByAggregateExprNodes, IList<ExprAggregateNodeGroupKey> groupKeyExpressions, bool hasGroupByClause, Attribute[] annotations, VariableCompileTimeResolver variableCompileTimeResolver, bool isDisallowNoReclaim, ExprNode whereClause, ExprNode havingClause, EventType[] typesPerStream, AggregationGroupByRollupDescForge groupByRollupDesc, string optionalContextName, IntoTableSpec intoTableSpec, TableCompileTimeResolver tableCompileTimeResolver, bool isUnidirectional, bool isFireAndForget, bool isOnSelect, ImportServiceCompileTime importService, StatementRawInfo raw, SerdeCompileTimeResolver serdeResolver) { // No aggregates used, we do not need this service if (selectAggregateExprNodes.IsEmpty() && havingAggregateExprNodes.IsEmpty()) { if (intoTableSpec != null) { throw new ExprValidationException("Into-table requires at least one aggregation function"); } return new AggregationServiceForgeDesc( AggregationServiceNullFactory.INSTANCE, EmptyList<AggregationServiceAggExpressionDesc>.Instance, EmptyList<ExprAggregateNodeGroupKey>.Instance, EmptyList<StmtClassForgeableFactory>.Instance); } // Validate the absence of "prev" function in where-clause: // Since the "previous" function does not post remove stream results, disallow when used with aggregations. if (whereClause != null || havingClause != null) { var visitor = new ExprNodePreviousVisitorWParent(); whereClause?.Accept(visitor); havingClause?.Accept(visitor); if (visitor.Previous != null && !visitor.Previous.IsEmpty()) { string funcname = visitor.Previous[0] .Second.PreviousType.ToString() .ToLowerInvariant(); throw new ExprValidationException( "The '" + funcname + "' function may not occur in the where-clause or having-clause of a statement with aggregations as 'previous' does not provide remove stream data; Use the 'first','last','window' or 'count' aggregation functions instead"); } } // Compile a map of aggregation nodes and equivalent-to aggregation nodes. // Equivalent-to functions are for example "select sum(a*b), 5*sum(a*b)". // Reducing the total number of aggregation functions. var aggregations = new List<AggregationServiceAggExpressionDesc>(); var intoTableNonRollup = groupByRollupDesc == null && intoTableSpec != null; foreach (var selectAggNode in selectAggregateExprNodes) { AddEquivalent(selectAggNode, aggregations, intoTableNonRollup); } foreach (var havingAggNode in havingAggregateExprNodes) { AddEquivalent(havingAggNode, aggregations, intoTableNonRollup); } foreach (var orderByAggNode in orderByAggregateExprNodes) { AddEquivalent(orderByAggNode, aggregations, intoTableNonRollup); } // Construct a list of evaluation node for the aggregation functions (regular agg). // For example "sum(2 * 3)" would make the sum an evaluation node. IList<ExprForge[]> methodAggForgesList = new List<ExprForge[]>(); foreach (var aggregation in aggregations) { var aggregateNode = aggregation.AggregationNode; if (!aggregateNode.Factory.IsAccessAggregation) { var forges = aggregateNode.Factory.GetMethodAggregationForge( typesPerStream.Length > 1, typesPerStream); methodAggForgesList.Add(forges); } } // determine local group-by, report when hook provided var localGroupDesc = AnalyzeLocalGroupBy(aggregations, groupByNodes, groupByRollupDesc, intoTableSpec); // determine binding if (intoTableSpec != null) { // obtain metadata var metadata = tableCompileTimeResolver.Resolve(intoTableSpec.Name); if (metadata == null) { throw new ExprValidationException( "Invalid into-table clause: Failed to find table by name '" + intoTableSpec.Name + "'"); } EPLValidationUtil.ValidateContextName( true, intoTableSpec.Name, metadata.OptionalContextName, optionalContextName, false); // validate group keys var groupByTypes = ExprNodeUtilityQuery.GetExprResultTypes(groupByNodes); var keyTypes = metadata.IsKeyed ? metadata.KeyTypes : new Type[0]; ExprTableNodeUtil.ValidateExpressions( intoTableSpec.Name, groupByTypes, "group-by", groupByNodes, keyTypes, "group-by"); // determine how this binds to existing aggregations, assign column numbers var bindingMatchResult = MatchBindingsAssignColumnNumbers( intoTableSpec, metadata, aggregations, selectClauseNamedNodes, methodAggForgesList, declaredExpressions, importService, raw.StatementName); // return factory AggregationServiceFactoryForge serviceForgeX = new AggregationServiceFactoryForgeTable( metadata, bindingMatchResult.MethodPairs, bindingMatchResult.TargetStates, bindingMatchResult.Agents, groupByRollupDesc); return new AggregationServiceForgeDesc(serviceForgeX, aggregations, groupKeyExpressions, EmptyList<StmtClassForgeableFactory>.Instance); } // Assign a column number to each aggregation node. The regular aggregation goes first followed by access-aggregation. var columnNumber = 0; foreach (var entry in aggregations) { if (!entry.Factory.IsAccessAggregation) { entry.SetColumnNum(columnNumber++); } } foreach (var entry in aggregations) { if (entry.Factory.IsAccessAggregation) { entry.SetColumnNum(columnNumber++); } } // determine method aggregation factories and evaluators(non-access) var methodAggForges = methodAggForgesList.ToArray(); var methodAggFactories = new AggregationForgeFactory[methodAggForges.Length]; var count = 0; foreach (var aggregation in aggregations) { var aggregateNode = aggregation.AggregationNode; if (!aggregateNode.Factory.IsAccessAggregation) { methodAggFactories[count] = aggregateNode.Factory; count++; } } // handle access aggregations var multiFunctionAggPlan = AggregationMultiFunctionAnalysisHelper.AnalyzeAccessAggregations( aggregations, importService, isFireAndForget, raw.StatementName, groupByNodes); var accessorPairsForge = multiFunctionAggPlan.AccessorPairsForge; var accessFactories = multiFunctionAggPlan.StateFactoryForges; var hasAccessAgg = accessorPairsForge.Length > 0; var hasMethodAgg = methodAggFactories.Length > 0; AggregationServiceFactoryForge serviceForge; var useFlags = new AggregationUseFlags(isUnidirectional, isFireAndForget, isOnSelect); var additionalForgeables = new List<StmtClassForgeableFactory>(); // analyze local group by AggregationLocalGroupByPlanForge localGroupByPlan = null; if (localGroupDesc != null) { AggregationLocalGroupByPlanDesc plan = AggregationGroupByLocalGroupByAnalyzer.Analyze( methodAggForges, methodAggFactories, accessFactories, localGroupDesc, groupByNodes, groupByMultiKey, accessorPairsForge, raw, serdeResolver); localGroupByPlan = plan.Forge; additionalForgeables.AddAll(plan.AdditionalForgeables); try { var hook = (AggregationLocalLevelHook) ImportUtil.GetAnnotationHook( annotations, HookType.INTERNAL_AGGLOCALLEVEL, typeof(AggregationLocalLevelHook), importService); hook?.Planned(localGroupDesc, localGroupByPlan); } catch (ExprValidationException) { throw new EPException("Failed to obtain hook for " + HookType.INTERNAL_AGGLOCALLEVEL); } } // Handle without a group-by clause: we group all into the same pot var rowStateDesc = new AggregationRowStateForgeDesc( hasMethodAgg ? methodAggFactories : null, hasMethodAgg ? methodAggForges : null, hasAccessAgg ? accessFactories : null, hasAccessAgg ? accessorPairsForge : null, useFlags); if (!hasGroupByClause) { if (localGroupByPlan != null) { serviceForge = new AggSvcLocalGroupByForge(false, localGroupByPlan, useFlags); } else { serviceForge = new AggregationServiceGroupAllForge(rowStateDesc); } } else { var groupDesc = new AggGroupByDesc( rowStateDesc, isUnidirectional, isFireAndForget, isOnSelect, groupByNodes, groupByMultiKey); var hasNoReclaim = HintEnum.DISABLE_RECLAIM_GROUP.GetHint(annotations) != null; var reclaimGroupAged = HintEnum.RECLAIM_GROUP_AGED.GetHint(annotations); var reclaimGroupFrequency = HintEnum.RECLAIM_GROUP_AGED.GetHint(annotations); if (localGroupByPlan != null) { serviceForge = new AggSvcLocalGroupByForge(true, localGroupByPlan, useFlags); } else { if (!isDisallowNoReclaim && hasNoReclaim) { if (groupByRollupDesc != null) { throw GetRollupReclaimEx(); } serviceForge = new AggregationServiceGroupByForge(groupDesc, importService.TimeAbacus); } else if (!isDisallowNoReclaim && reclaimGroupAged != null) { if (groupByRollupDesc != null) { throw GetRollupReclaimEx(); } CompileReclaim( groupDesc, reclaimGroupAged, reclaimGroupFrequency, variableCompileTimeResolver, optionalContextName); serviceForge = new AggregationServiceGroupByForge(groupDesc, importService.TimeAbacus); } else if (groupByRollupDesc != null) { serviceForge = new AggSvcGroupByRollupForge(rowStateDesc, groupByRollupDesc, groupByNodes); } else { groupDesc.IsRefcounted = true; serviceForge = new AggregationServiceGroupByForge(groupDesc, importService.TimeAbacus); } } } return new AggregationServiceForgeDesc(serviceForge, aggregations, groupKeyExpressions, additionalForgeables); }
private static ModuleCompileTimeServices GetServices( CompilerArguments arguments, string moduleName, ICollection<string> moduleUses, bool isFireAndForget) { var configuration = arguments.Configuration; var path = arguments.Path; var options = arguments.Options; // script var scriptCompiler = MakeScriptCompiler(configuration); // imports var importServiceCompileTime = MakeImportService(configuration); var classLoaderParent = new ParentClassLoader(importServiceCompileTime.ClassLoader); var container = importServiceCompileTime.Container; // resolve pre-configured bean event types, make bean-stem service var resolvedBeanEventTypes = BeanEventTypeRepoUtil.ResolveBeanEventTypes( configuration.Common.EventTypeNames, importServiceCompileTime); var beanEventTypeStemService = BeanEventTypeRepoUtil.MakeBeanEventTypeStemService( configuration, resolvedBeanEventTypes, EventBeanTypedEventFactoryCompileTime.INSTANCE); // allocate repositories var eventTypeRepositoryPreconfigured = new EventTypeRepositoryImpl(true); var eventTypeCompileRegistry = new EventTypeCompileTimeRegistry(eventTypeRepositoryPreconfigured); var beanEventTypeFactoryPrivate = new BeanEventTypeFactoryPrivate( EventBeanTypedEventFactoryCompileTime.INSTANCE, EventTypeFactoryImpl.GetInstance(container), beanEventTypeStemService); var variableRepositoryPreconfigured = new VariableRepositoryPreconfigured(); // allocate path registries var pathEventTypes = new PathRegistry<string, EventType>(PathRegistryObjectType.EVENTTYPE); var pathNamedWindows = new PathRegistry<string, NamedWindowMetaData>(PathRegistryObjectType.NAMEDWINDOW); var pathTables = new PathRegistry<string, TableMetaData>(PathRegistryObjectType.TABLE); var pathContexts = new PathRegistry<string, ContextMetaData>(PathRegistryObjectType.CONTEXT); var pathVariables = new PathRegistry<string, VariableMetaData>(PathRegistryObjectType.VARIABLE); var pathExprDeclared = new PathRegistry<string, ExpressionDeclItem>(PathRegistryObjectType.EXPRDECL); var pathScript = new PathRegistry<NameAndParamNum, ExpressionScriptProvided>(PathRegistryObjectType.SCRIPT); var pathClassProvided = new PathRegistry<string, ClassProvided>(PathRegistryObjectType.CLASSPROVIDED); // add runtime-path which is the information an existing runtime may have if (path.CompilerPathables != null) { foreach (EPCompilerPathable pathable in path.CompilerPathables) { EPCompilerPathableImpl impl = (EPCompilerPathableImpl) pathable; pathVariables.MergeFrom(impl.VariablePathRegistry); pathEventTypes.MergeFrom(impl.EventTypePathRegistry); pathExprDeclared.MergeFrom(impl.ExprDeclaredPathRegistry); pathNamedWindows.MergeFrom(impl.NamedWindowPathRegistry); pathTables.MergeFrom(impl.TablePathRegistry); pathContexts.MergeFrom(impl.ContextPathRegistry); pathScript.MergeFrom(impl.ScriptPathRegistry); pathClassProvided.MergeFrom(impl.ClassProvidedPathRegistry); eventTypeRepositoryPreconfigured.MergeFrom(impl.EventTypePreconfigured); variableRepositoryPreconfigured.MergeFrom(impl.VariablePreconfigured); JsonEventTypeUtility.AddJsonUnderlyingClass(pathEventTypes, classLoaderParent); } } // build preconfigured type system EventTypeRepositoryBeanTypeUtil.BuildBeanTypes( beanEventTypeStemService, eventTypeRepositoryPreconfigured, resolvedBeanEventTypes, beanEventTypeFactoryPrivate, configuration.Common.EventTypesBean); EventTypeRepositoryMapTypeUtil.BuildMapTypes( eventTypeRepositoryPreconfigured, configuration.Common.MapTypeConfigurations, configuration.Common.EventTypesMapEvents, configuration.Common.EventTypesNestableMapEvents, beanEventTypeFactoryPrivate, importServiceCompileTime); EventTypeRepositoryOATypeUtil.BuildOATypes( eventTypeRepositoryPreconfigured, configuration.Common.ObjectArrayTypeConfigurations, configuration.Common.EventTypesNestableObjectArrayEvents, beanEventTypeFactoryPrivate, importServiceCompileTime); XMLFragmentEventTypeFactory xmlFragmentEventTypeFactory = new XMLFragmentEventTypeFactory( beanEventTypeFactoryPrivate, eventTypeCompileRegistry, eventTypeRepositoryPreconfigured); EventTypeRepositoryXMLTypeUtil.BuildXMLTypes( eventTypeRepositoryPreconfigured, configuration.Common.EventTypesXMLDOM, beanEventTypeFactoryPrivate, xmlFragmentEventTypeFactory, container.ResourceManager()); EventTypeAvroHandler eventTypeAvroHandler = EventTypeAvroHandlerFactory.Resolve( importServiceCompileTime, configuration.Common.EventMeta.AvroSettings, EventTypeAvroHandlerConstants.COMPILE_TIME_HANDLER_IMPL); EventTypeRepositoryAvroTypeUtil.BuildAvroTypes( eventTypeRepositoryPreconfigured, configuration.Common.EventTypesAvro, eventTypeAvroHandler, beanEventTypeFactoryPrivate.EventBeanTypedEventFactory); EventTypeRepositoryVariantStreamUtil.BuildVariantStreams( eventTypeRepositoryPreconfigured, configuration.Common.VariantStreams, EventTypeFactoryImpl.GetInstance(container)); // build preconfigured variables VariableUtil.ConfigureVariables( variableRepositoryPreconfigured, configuration.Common.Variables, importServiceCompileTime, EventBeanTypedEventFactoryCompileTime.INSTANCE, eventTypeRepositoryPreconfigured, beanEventTypeFactoryPrivate); var deploymentNumber = -1; foreach (var unit in path.Compileds) { deploymentNumber++; var provider = ModuleProviderUtil.Analyze(unit, classLoaderParent, pathClassProvided); var unitModuleName = provider.ModuleProvider.ModuleName; // initialize event types var moduleTypes = new Dictionary<string, EventType>(); var eventTypeResolver = new EventTypeResolverImpl( moduleTypes, pathEventTypes, eventTypeRepositoryPreconfigured, beanEventTypeFactoryPrivate, EventSerdeFactoryDefault.INSTANCE); var eventTypeCollector = new EventTypeCollectorImpl( container, moduleTypes, beanEventTypeFactoryPrivate, provider.ClassLoader, EventTypeFactoryImpl.GetInstance(container), beanEventTypeStemService, eventTypeResolver, xmlFragmentEventTypeFactory, eventTypeAvroHandler, EventBeanTypedEventFactoryCompileTime.INSTANCE, importServiceCompileTime); try { provider.ModuleProvider.InitializeEventTypes( new EPModuleEventTypeInitServicesImpl(eventTypeCollector, eventTypeResolver)); } catch (Exception e) { throw new EPException(e); } JsonEventTypeUtility.AddJsonUnderlyingClass(moduleTypes, classLoaderParent, null); // initialize named windows var moduleNamedWindows = new Dictionary<string, NamedWindowMetaData>(); var namedWindowCollector = new NamedWindowCollectorImpl(moduleNamedWindows); try { provider.ModuleProvider.InitializeNamedWindows( new EPModuleNamedWindowInitServicesImpl(namedWindowCollector, eventTypeResolver)); } catch (Exception e) { throw new EPException(e); } // initialize tables var moduleTables = new Dictionary<string, TableMetaData>(); var tableCollector = new TableCollectorImpl(moduleTables); try { provider.ModuleProvider.InitializeTables( new EPModuleTableInitServicesImpl(tableCollector, eventTypeResolver)); } catch (Exception e) { throw new EPException(e); } // initialize create-index indexes var indexCollector = new IndexCollectorCompileTime( moduleNamedWindows, moduleTables, pathNamedWindows, pathTables); try { provider.ModuleProvider.InitializeIndexes(new EPModuleIndexInitServicesImpl(indexCollector)); } catch (Exception e) { throw new EPException(e); } // initialize create-contexts var moduleContexts = new Dictionary<string, ContextMetaData>(); var contextCollector = new ContextCollectorImpl(moduleContexts); try { provider.ModuleProvider.InitializeContexts( new EPModuleContextInitServicesImpl(contextCollector, eventTypeResolver)); } catch (Exception e) { throw new EPException(e); } // initialize variables var moduleVariables = new Dictionary<string, VariableMetaData>(); var variableCollector = new VariableCollectorImpl(moduleVariables); try { provider.ModuleProvider.InitializeVariables( new EPModuleVariableInitServicesImpl(variableCollector, eventTypeResolver)); } catch (Exception e) { throw new EPException(e); } // initialize module expressions var moduleExprDeclareds = new Dictionary<string, ExpressionDeclItem>(); var exprDeclaredCollector = new ExprDeclaredCollectorCompileTime(moduleExprDeclareds); try { provider.ModuleProvider.InitializeExprDeclareds( new EPModuleExprDeclaredInitServicesImpl(exprDeclaredCollector)); } catch (Exception e) { throw new EPException(e); } // initialize module scripts var moduleScripts = new Dictionary<NameAndParamNum, ExpressionScriptProvided>(); var scriptCollector = new ScriptCollectorCompileTime(moduleScripts); try { provider.ModuleProvider.InitializeScripts(new EPModuleScriptInitServicesImpl(scriptCollector)); } catch (Exception e) { throw new EPException(e); } // initialize inlined classes var moduleClassProvideds = new Dictionary<string, ClassProvided>(); var classProvidedCollector = new ClassProvidedCollectorCompileTime(moduleClassProvideds, classLoaderParent); try { provider.ModuleProvider.InitializeClassProvided(new EPModuleClassProvidedInitServicesImpl(classProvidedCollector)); } catch (Exception e) { throw new EPException(e); } // save path-visibility event types and named windows to the path var deploymentId = "D" + deploymentNumber; try { foreach (var type in moduleTypes) { if (type.Value.Metadata.AccessModifier.IsNonPrivateNonTransient()) { pathEventTypes.Add(type.Key, unitModuleName, type.Value, deploymentId); } } foreach (var entry in moduleNamedWindows) { if (entry.Value.EventType.Metadata.AccessModifier.IsNonPrivateNonTransient()) { pathNamedWindows.Add(entry.Key, unitModuleName, entry.Value, deploymentId); } } foreach (var entry in moduleTables) { if (entry.Value.TableVisibility.IsNonPrivateNonTransient()) { pathTables.Add(entry.Key, unitModuleName, entry.Value, deploymentId); } } foreach (var entry in moduleContexts) { if (entry.Value.ContextVisibility.IsNonPrivateNonTransient()) { pathContexts.Add(entry.Key, unitModuleName, entry.Value, deploymentId); } } foreach (var entry in moduleVariables) { if (entry.Value.VariableVisibility.IsNonPrivateNonTransient()) { pathVariables.Add(entry.Key, unitModuleName, entry.Value, deploymentId); } } foreach (var entry in moduleExprDeclareds) { if (entry.Value.Visibility.IsNonPrivateNonTransient()) { pathExprDeclared.Add(entry.Key, unitModuleName, entry.Value, deploymentId); } } foreach (var entry in moduleScripts) { if (entry.Value.Visibility.IsNonPrivateNonTransient()) { pathScript.Add(entry.Key, unitModuleName, entry.Value, deploymentId); } } foreach (var entry in moduleClassProvideds) { if (entry.Value.Visibility.IsNonPrivateNonTransient()) { pathClassProvided.Add(entry.Key, unitModuleName, entry.Value, deploymentId); } } } catch (PathException ex) { throw new EPCompileException( "Invalid path: " + ex.Message, ex, new EmptyList<EPCompileExceptionItem>()); } } var moduleDependencies = new ModuleDependenciesCompileTime(); // build bean space of public and protected var eventTypeCompileTimeResolver = new EventTypeCompileTimeResolver( moduleName, moduleUses, eventTypeCompileRegistry, eventTypeRepositoryPreconfigured, pathEventTypes, moduleDependencies, isFireAndForget); // build named window registry var namedWindowCompileTimeRegistry = new NamedWindowCompileTimeRegistry(); var namedWindowCompileTimeResolver = new NamedWindowCompileTimeResolverImpl( moduleName, moduleUses, namedWindowCompileTimeRegistry, pathNamedWindows, moduleDependencies, isFireAndForget); // build context registry var contextCompileTimeRegistry = new ContextCompileTimeRegistry(); var contextCompileTimeResolver = new ContextCompileTimeResolverImpl( moduleName, moduleUses, contextCompileTimeRegistry, pathContexts, moduleDependencies, isFireAndForget); // build variable registry var variableCompileTimeRegistry = new VariableCompileTimeRegistry(); var variableCompileTimeResolver = new VariableCompileTimeResolverImpl( moduleName, moduleUses, variableRepositoryPreconfigured, variableCompileTimeRegistry, pathVariables, moduleDependencies, isFireAndForget); // build declared-expression registry var exprDeclaredCompileTimeRegistry = new ExprDeclaredCompileTimeRegistry(); var exprDeclaredCompileTimeResolver = new ExprDeclaredCompileTimeResolverImpl( moduleName, moduleUses, exprDeclaredCompileTimeRegistry, pathExprDeclared, moduleDependencies, isFireAndForget); // build table-registry var localTables = new Dictionary<string, TableMetaData>(); var tableCompileTimeRegistry = new TableCompileTimeRegistry(localTables); var tableCompileTimeResolver = new TableCompileTimeResolverImpl( moduleName, moduleUses, tableCompileTimeRegistry, pathTables, moduleDependencies, isFireAndForget); // build script registry var scriptCompileTimeRegistry = new ScriptCompileTimeRegistry(); var scriptCompileTimeResolver = new ScriptCompileTimeResolverImpl( moduleName, moduleUses, scriptCompileTimeRegistry, pathScript, moduleDependencies, isFireAndForget); // build classes registry var classProvidedCompileTimeRegistry = new ClassProvidedCompileTimeRegistry(); var classProvidedCompileTimeResolver = new ClassProvidedCompileTimeResolverImpl( moduleName, moduleUses, classProvidedCompileTimeRegistry, pathClassProvided, moduleDependencies, isFireAndForget); // view resolution var plugInViews = new PluggableObjectCollection(); plugInViews.AddViews( configuration.Compiler.PlugInViews, configuration.Compiler.PlugInVirtualDataWindows, importServiceCompileTime); var viewRegistry = new PluggableObjectRegistryImpl(new[] {ViewEnumHelper.BuiltinViews, plugInViews}); ViewResolutionService viewResolutionService = new ViewResolutionServiceImpl(viewRegistry); var plugInPatternObj = new PluggableObjectCollection(); plugInPatternObj.AddPatternObjects(configuration.Compiler.PlugInPatternObjects, importServiceCompileTime); plugInPatternObj.AddObjects(PatternObjectHelper.BuiltinPatternObjects); PatternObjectResolutionService patternResolutionService = new PatternObjectResolutionServiceImpl(plugInPatternObj); var indexCompileTimeRegistry = new IndexCompileTimeRegistry(new Dictionary<IndexCompileTimeKey, IndexDetailForge>()); var moduleVisibilityRules = new ModuleAccessModifierServiceImpl(options, configuration.Compiler.ByteCode); var databaseConfigServiceCompileTime = new DatabaseConfigServiceImpl( container, configuration.Common.DatabaseReferences, importServiceCompileTime); var compilerServices = new CompilerServicesImpl(); var targetHA = configuration.GetType().Name.EndsWith("ConfigurationHA"); var serdeEventTypeRegistry = new SerdeEventTypeCompileTimeRegistryImpl(targetHA); SerdeCompileTimeResolver serdeResolver = targetHA ? MakeSerdeResolver(configuration.Compiler.Serde, configuration.Common.TransientConfiguration) : SerdeCompileTimeResolverNonHA.INSTANCE; return new ModuleCompileTimeServices( container, compilerServices, configuration, contextCompileTimeRegistry, contextCompileTimeResolver, beanEventTypeStemService, beanEventTypeFactoryPrivate, classProvidedCompileTimeRegistry, classProvidedCompileTimeResolver, databaseConfigServiceCompileTime, importServiceCompileTime, exprDeclaredCompileTimeRegistry, exprDeclaredCompileTimeResolver, eventTypeAvroHandler, eventTypeCompileRegistry, eventTypeCompileTimeResolver, eventTypeRepositoryPreconfigured, isFireAndForget, indexCompileTimeRegistry, moduleDependencies, moduleVisibilityRules, namedWindowCompileTimeResolver, namedWindowCompileTimeRegistry, classLoaderParent, patternResolutionService, scriptCompileTimeRegistry, scriptCompileTimeResolver, scriptCompiler, serdeEventTypeRegistry, serdeResolver, tableCompileTimeRegistry, tableCompileTimeResolver, variableCompileTimeRegistry, variableCompileTimeResolver, viewResolutionService, xmlFragmentEventTypeFactory); }