private AbstractAllGroupHeadsCollector CreateRandomCollector(string groupField, Sort sortWithinGroup, bool canUseIDV, DocValuesType valueType) { AbstractAllGroupHeadsCollector collector; if (Random.nextBoolean()) { ValueSource vs = new BytesRefFieldSource(groupField); collector = new FunctionAllGroupHeadsCollector(vs, new Hashtable(), sortWithinGroup); } else { collector = TermAllGroupHeadsCollector.Create(groupField, sortWithinGroup); } if (VERBOSE) { Console.WriteLine("Selected implementation: " + collector.GetType().Name); } return(collector); }
//LUCENENET: Method replaced by two methods GroupByField and GroupByFunction so that a generic type constraint // can be added to the GroupByFunction case. //protected virtual ITopGroups GroupByFieldOrFunction(IndexSearcher searcher, Filter filter, Query query, int groupOffset, int groupLimit) //{ //} //LUCENENET Specific. One of two methods that replace GroupByFieldOrFunction. Used support SearchByField. // This method is essentually a Field specific version of the GroupByFieldOrFunction. protected virtual ITopGroups <TGroupValue> GroupByField <TGroupValue>(IndexSearcher searcher, Filter filter, Query query, int groupOffset, int groupLimit) { int topN = groupOffset + groupLimit; IAbstractFirstPassGroupingCollector <TGroupValue> firstPassCollector; IAbstractAllGroupsCollector <TGroupValue> allGroupsCollector; AbstractAllGroupHeadsCollector allGroupHeadsCollector; if (groupField is null) { throw IllegalStateException.Create("groupField must be set via the constructor."); } firstPassCollector = (IAbstractFirstPassGroupingCollector <TGroupValue>) new TermFirstPassGroupingCollector(groupField, groupSort, topN); if (allGroups) { allGroupsCollector = (IAbstractAllGroupsCollector <TGroupValue>) new TermAllGroupsCollector(groupField, initialSize); } else { allGroupsCollector = null; } if (allGroupHeads) { allGroupHeadsCollector = TermAllGroupHeadsCollector.Create(groupField, sortWithinGroup, initialSize); } else { allGroupHeadsCollector = null; } ICollector firstRound; if (allGroupHeads || allGroups) { List <ICollector> collectors = new List <ICollector>(); collectors.Add(firstPassCollector); if (allGroups) { collectors.Add(allGroupsCollector); } if (allGroupHeads) { collectors.Add(allGroupHeadsCollector); } firstRound = MultiCollector.Wrap(collectors.ToArray(/* new Collector[collectors.size()] */)); } else { firstRound = firstPassCollector; } CachingCollector cachedCollector = null; if (maxCacheRAMMB != null || maxDocsToCache != null) { if (maxCacheRAMMB != null) { cachedCollector = CachingCollector.Create(firstRound, cacheScores, maxCacheRAMMB.Value); } else { cachedCollector = CachingCollector.Create(firstRound, cacheScores, maxDocsToCache.Value); } searcher.Search(query, filter, cachedCollector); } else { searcher.Search(query, filter, firstRound); } if (allGroups) { matchingGroups = (ICollection)allGroupsCollector.Groups; } else { matchingGroups = (ICollection)Collections.EmptyList <TGroupValue>(); } if (allGroupHeads) { matchingGroupHeads = allGroupHeadsCollector.RetrieveGroupHeads(searcher.IndexReader.MaxDoc); } else { matchingGroupHeads = new Bits.MatchNoBits(searcher.IndexReader.MaxDoc); } IEnumerable <ISearchGroup <TGroupValue> > topSearchGroups = firstPassCollector.GetTopGroups(groupOffset, fillSortFields); if (topSearchGroups == null) { // LUCENENET specific - optimized empty array creation return(new TopGroups <TGroupValue>(Arrays.Empty <SortField>(), Arrays.Empty <SortField>(), 0, 0, Arrays.Empty <GroupDocs <TGroupValue> >(), float.NaN)); } int topNInsideGroup = groupDocsOffset + groupDocsLimit; IAbstractSecondPassGroupingCollector <TGroupValue> secondPassCollector; secondPassCollector = new TermSecondPassGroupingCollector(groupField, topSearchGroups as IEnumerable <ISearchGroup <BytesRef> >, groupSort, sortWithinGroup, topNInsideGroup, includeScores, includeMaxScore, fillSortFields) as IAbstractSecondPassGroupingCollector <TGroupValue>; if (cachedCollector != null && cachedCollector.IsCached) { cachedCollector.Replay(secondPassCollector); } else { searcher.Search(query, filter, secondPassCollector); } if (allGroups) { return(new TopGroups <TGroupValue>(secondPassCollector.GetTopGroups(groupDocsOffset), matchingGroups.Count)); } else { return(secondPassCollector.GetTopGroups(groupDocsOffset)); } }
protected virtual ITopGroups <TGroupValue> GroupByFieldOrFunction <TGroupValue>(IndexSearcher searcher, Filter filter, Query query, int groupOffset, int groupLimit) { int topN = groupOffset + groupLimit; IAbstractFirstPassGroupingCollector <TGroupValue> firstPassCollector; IAbstractAllGroupsCollector <TGroupValue> allGroupsCollector; AbstractAllGroupHeadsCollector allGroupHeadsCollector; if (groupFunction != null) { firstPassCollector = (IAbstractFirstPassGroupingCollector <TGroupValue>) new FunctionFirstPassGroupingCollector(groupFunction, valueSourceContext, groupSort, topN); if (allGroups) { allGroupsCollector = (IAbstractAllGroupsCollector <TGroupValue>) new FunctionAllGroupsCollector(groupFunction, valueSourceContext); } else { allGroupsCollector = null; } if (allGroupHeads) { allGroupHeadsCollector = new FunctionAllGroupHeadsCollector(groupFunction, valueSourceContext, sortWithinGroup); } else { allGroupHeadsCollector = null; } } else { firstPassCollector = (IAbstractFirstPassGroupingCollector <TGroupValue>) new TermFirstPassGroupingCollector(groupField, groupSort, topN); if (allGroups) { allGroupsCollector = (IAbstractAllGroupsCollector <TGroupValue>) new TermAllGroupsCollector(groupField, initialSize); } else { allGroupsCollector = null; } if (allGroupHeads) { allGroupHeadsCollector = TermAllGroupHeadsCollector.Create(groupField, sortWithinGroup, initialSize); } else { allGroupHeadsCollector = null; } } Collector firstRound; if (allGroupHeads || allGroups) { List <Collector> collectors = new List <Collector>(); // LUCENENET TODO: Make the Collector abstract class into an interface // so we can remove the casting here collectors.Add((Collector)firstPassCollector); if (allGroups) { // LUCENENET TODO: Make the Collector abstract class into an interface // so we can remove the casting here collectors.Add((Collector)allGroupsCollector); } if (allGroupHeads) { collectors.Add(allGroupHeadsCollector); } firstRound = MultiCollector.Wrap(collectors.ToArray(/* new Collector[collectors.size()] */)); } else { // LUCENENET TODO: Make the Collector abstract class into an interface // so we can remove the casting here firstRound = (Collector)firstPassCollector; } CachingCollector cachedCollector = null; if (maxCacheRAMMB != null || maxDocsToCache != null) { if (maxCacheRAMMB != null) { cachedCollector = CachingCollector.Create(firstRound, cacheScores, maxCacheRAMMB.Value); } else { cachedCollector = CachingCollector.Create(firstRound, cacheScores, maxDocsToCache.Value); } searcher.Search(query, filter, cachedCollector); } else { searcher.Search(query, filter, firstRound); } if (allGroups) { matchingGroups = (IList)allGroupsCollector.Groups; } else { matchingGroups = new List <TGroupValue>(); } if (allGroupHeads) { matchingGroupHeads = allGroupHeadsCollector.RetrieveGroupHeads(searcher.IndexReader.MaxDoc); } else { matchingGroupHeads = new Bits_MatchNoBits(searcher.IndexReader.MaxDoc); } IEnumerable <ISearchGroup <TGroupValue> > topSearchGroups = firstPassCollector.GetTopGroups(groupOffset, fillSortFields); if (topSearchGroups == null) { return(new TopGroups <TGroupValue>(new SortField[0], new SortField[0], 0, 0, new GroupDocs <TGroupValue> [0], float.NaN)); } int topNInsideGroup = groupDocsOffset + groupDocsLimit; IAbstractSecondPassGroupingCollector <TGroupValue> secondPassCollector; if (groupFunction != null) { secondPassCollector = new FunctionSecondPassGroupingCollector(topSearchGroups as IEnumerable <ISearchGroup <MutableValue> >, groupSort, sortWithinGroup, topNInsideGroup, includeScores, includeMaxScore, fillSortFields, groupFunction, valueSourceContext) as IAbstractSecondPassGroupingCollector <TGroupValue>; } else { secondPassCollector = new TermSecondPassGroupingCollector(groupField, topSearchGroups as IEnumerable <ISearchGroup <BytesRef> >, groupSort, sortWithinGroup, topNInsideGroup, includeScores, includeMaxScore, fillSortFields) as IAbstractSecondPassGroupingCollector <TGroupValue>; } if (cachedCollector != null && cachedCollector.Cached) { // LUCENENET TODO: Create an ICollector interface that we can inherit our Collector interfaces from // so this cast is not necessary. Consider eliminating the Collector abstract class. cachedCollector.Replay(secondPassCollector as Collector); } else { // LUCENENET TODO: Create an ICollector interface that we can inherit our Collector interfaces from // so this cast is not necessary. Consider eliminating the Collector abstract class. searcher.Search(query, filter, secondPassCollector as Collector); } if (allGroups) { return(new TopGroups <TGroupValue>(secondPassCollector.GetTopGroups(groupDocsOffset), matchingGroups.Count)); } else { return(secondPassCollector.GetTopGroups(groupDocsOffset)); } }