//Lookup by group string value
private void LookupGroupsbyString(Directory directory)
{
Filter groupEndDocs = new CachingWrapperFilter(new QueryWrapperFilter(new TermQuery(new Term("groupEnd", "x"))));
IndexReader indexReader = DirectoryReader.Open(directory);
IndexSearcher indexSearcher = new IndexSearcher(indexReader);
BlockGroupingCollector blockGroupingCollector = new BlockGroupingCollector(Sort.RELEVANCE, 10, true, groupEndDocs);
indexSearcher.Search(new MatchAllDocsQuery(), null, blockGroupingCollector);
var topGroups = blockGroupingCollector.GetTopGroups(Sort.RELEVANCE, 0, 0, 10, true);
Console.WriteLine("Total group count: " + topGroups.TotalGroupCount);
Console.WriteLine("Total group hit count: " + topGroups.TotalGroupedHitCount);
foreach (var groupDocs in topGroups.Groups)
{
Console.WriteLine("Group: " + groupDocs.GroupValue);
foreach (var scoreDoc in groupDocs.ScoreDocs)
{
Document doc = indexSearcher.Doc(scoreDoc.Doc);
Console.WriteLine("Category: " + doc.GetField("Category").GetStringValue() + ", BookId: " + doc.GetField("BookId").GetStringValue());
}
}
indexReader.Dispose();
}
public virtual void TestWithCachingFilter()
{
Directory dir = NewDirectory();
RandomIndexWriter writer = new RandomIndexWriter(
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
this,
#endif
Random, dir);
IndexReader reader = writer.GetReader();
writer.Dispose();
IndexSearcher searcher = NewSearcher(reader);
Query query = new TermQuery(new Term("none", "none"));
QueryWrapperFilter queryFilter = new QueryWrapperFilter(query);
CachingWrapperFilter cachingFilter = new CachingWrapperFilter(queryFilter);
searcher.Search(query, cachingFilter, 1);
CachingWrapperFilter cachingFilter2 = new CachingWrapperFilter(queryFilter);
Filter[] chain = new Filter[2];
chain[0] = cachingFilter;
chain[1] = cachingFilter2;
ChainedFilter cf = new ChainedFilter(chain);
// throws java.lang.ClassCastException: org.apache.lucene.util.OpenBitSet cannot be cast to java.util.BitSet
searcher.Search(new MatchAllDocsQuery(), cf, 1);
reader.Dispose();
dir.Dispose();
}
public Filter GetFilter(string tenantId, string[] types)
{
Filter visibilityFilter = GetVisibilityFilter(tenantId);
Filter typeFilter = new CachingWrapperFilter(new TypeFilter(types));
return(new ChainedFilter(new Filter[] { visibilityFilter, typeFilter }, ChainedFilter.Logic.AND));
}
public virtual void TestWithCachingFilter()
{
Directory dir = NewDirectory();
RandomIndexWriter writer = new RandomIndexWriter(Random(), dir, Similarity, TimeZone);
IndexReader reader = writer.Reader;
writer.Dispose();
IndexSearcher searcher = NewSearcher(reader);
Query query = new TermQuery(new Term("none", "none"));
QueryWrapperFilter queryFilter = new QueryWrapperFilter(query);
CachingWrapperFilter cachingFilter = new CachingWrapperFilter(queryFilter);
searcher.Search(query, cachingFilter, 1);
CachingWrapperFilter cachingFilter2 = new CachingWrapperFilter(queryFilter);
Filter[] chain = new Filter[2];
chain[0] = cachingFilter;
chain[1] = cachingFilter2;
ChainedFilter cf = new ChainedFilter(chain);
// throws java.lang.ClassCastException: org.apache.lucene.util.OpenBitSet cannot be cast to java.util.BitSet
searcher.Search(new MatchAllDocsQuery(), cf, 1);
reader.Dispose();
dir.Dispose();
}
public void TestWithCachingFilter()
{
Directory dir = new RAMDirectory();
Analyzer analyzer = new WhitespaceAnalyzer();
IndexWriter writer = new IndexWriter(dir, analyzer, true, IndexWriter.MaxFieldLength.LIMITED);
writer.Close();
Searcher searcher = new IndexSearcher(dir, true);
Query query = new TermQuery(new Term("none", "none"));
QueryWrapperFilter queryFilter = new QueryWrapperFilter(query);
CachingWrapperFilter cachingFilter = new CachingWrapperFilter(queryFilter);
searcher.Search(query, cachingFilter, 1);
CachingWrapperFilter cachingFilter2 = new CachingWrapperFilter(queryFilter);
Filter[] chain = new Filter[2];
chain[0] = cachingFilter;
chain[1] = cachingFilter2;
ChainedFilter cf = new ChainedFilter(chain);
// throws java.lang.ClassCastException: org.apache.lucene.util.OpenBitSet cannot be cast to java.util.BitSet
searcher.Search(new MatchAllDocsQuery(), cf, 1);
}
public Filter GetFilter(string tenantId, string[] types, bool includePrerelease, bool includeUnlisted)
{
Filter visibilityFilter = GetVisibilityFilter(tenantId);
Filter typeFilter = new CachingWrapperFilter(new TypeFilter(types));
Filter versionFilter = GetVersionFilter(includePrerelease, includeUnlisted);
return(new ChainedFilter(new Filter[] { visibilityFilter, versionFilter, typeFilter }, ChainedFilter.Logic.AND));
}
private IEnumerable <FacetMatch> FindMatchesInQuery(Query baseQueryWithoutFacetDrilldown, IList <FacetFieldInfo> allFacetFieldInfos, FacetFieldInfo facetFieldInfoToCalculateFor)
{
var calculations = 0;
var queryFilter = new CachingWrapperFilter(new QueryWrapperFilter(CreateFacetedQuery(baseQueryWithoutFacetDrilldown, allFacetFieldInfos, facetFieldInfoToCalculateFor.FieldName)));
var bitsQueryWithoutFacetDrilldown = new OpenBitSetDISI(queryFilter.GetDocIdSet(IndexReader).Iterator(), IndexReader.MaxDoc);
var baseQueryWithoutFacetDrilldownCopy = new OpenBitSetDISI(bitsQueryWithoutFacetDrilldown.Bits.Length)
{
Bits = new long[bitsQueryWithoutFacetDrilldown.Bits.Length]
};
var calculatedFacetCounts = new ResultCollection(facetFieldInfoToCalculateFor);
foreach (var facetValueBitSet in GetOrCreateFacetBitSet(facetFieldInfoToCalculateFor.FieldName).FacetValueBitSetList)
{
var isSelected = calculatedFacetCounts.IsSelected(facetValueBitSet.Value);
if (!isSelected && facetValueBitSet.Count < calculatedFacetCounts.MinCountForNonSelected) //Impossible to get a better result
{
if (calculatedFacetCounts.HaveEnoughResults)
{
break;
}
}
bitsQueryWithoutFacetDrilldown.Bits.CopyTo(baseQueryWithoutFacetDrilldownCopy.Bits, 0);
baseQueryWithoutFacetDrilldownCopy.NumWords = bitsQueryWithoutFacetDrilldown.NumWords;
var bitset = facetValueBitSet.Bitset ?? CalculateOpenBitSetDisi(facetFieldInfoToCalculateFor.FieldName, facetValueBitSet.Value);
baseQueryWithoutFacetDrilldownCopy.And(bitset);
var count = baseQueryWithoutFacetDrilldownCopy.Cardinality();
if (count == 0)
{
continue;
}
var match = new FacetMatch
{
Count = count,
Value = facetValueBitSet.Value,
FacetFieldName = facetFieldInfoToCalculateFor.FieldName
};
calculations++;
if (isSelected)
{
calculatedFacetCounts.AddToSelected(match);
}
else
{
calculatedFacetCounts.AddToNonSelected(match);
}
}
return(calculatedFacetCounts.GetList());
}
public virtual Filter GetFilter(XmlElement e)
{
UninterruptableMonitor.Enter(this);
try
{
XmlElement childElement = DOMUtils.GetFirstChildOrFail(e);
if (filterCache is null)
{
filterCache = new LurchTable <object, Filter>(LurchTableOrder.Access, cacheSize);
}
// Test to see if child Element is a query or filter that needs to be
// cached
IQueryBuilder qb = queryFactory.GetQueryBuilder(childElement.Name);
object cacheKey = null;
Query q = null;
Filter f = null;
if (qb != null)
{
q = qb.GetQuery(childElement);
cacheKey = q;
}
else
{
f = filterFactory.GetFilter(childElement);
cacheKey = f;
}
if (filterCache.TryGetValue(cacheKey, out Filter cachedFilter) && cachedFilter != null)
{
return(cachedFilter); // cache hit
}
//cache miss
if (qb != null)
{
cachedFilter = new QueryWrapperFilter(q);
}
else
{
cachedFilter = new CachingWrapperFilter(f);
}
filterCache[cacheKey] = cachedFilter;
return(cachedFilter);
}
finally
{
UninterruptableMonitor.Exit(this);
}
}
//Lookup by group int value (Alternative Syntax)
private void LookupGroupsByIntAlt(Directory directory)
{
Filter groupEndDocs = new CachingWrapperFilter(new QueryWrapperFilter(new TermQuery(new Term("groupEnd", "x"))));
IndexReader indexReader = DirectoryReader.Open(directory);
IndexSearcher indexSearcher = new IndexSearcher(indexReader);
GroupingSearch groupingSearch = new GroupingSearch(groupEndDocs);
groupingSearch.SetGroupSort(new Sort());
groupingSearch.SetIncludeScores(true);
Query query = NumericRangeQuery.NewInt32Range("Repetition", 1, 2, true, false);
var groupsResult = groupingSearch.Search(indexSearcher, query, 0, 10); //search(indexSearcher, query, groupOffset, groupLimit);
indexReader.Dispose();
}
//Lookup by group string value (Alternative Syntax)
private void LookupGroupsByStringAlt(Directory directory)
{
Filter groupEndDocs = new CachingWrapperFilter(new QueryWrapperFilter(new TermQuery(new Term("groupEnd", "x"))));
IndexReader indexReader = DirectoryReader.Open(directory);
IndexSearcher indexSearcher = new IndexSearcher(indexReader);
GroupingSearch groupingSearch = new GroupingSearch(groupEndDocs);
groupingSearch.SetGroupSort(new Sort());
groupingSearch.SetIncludeScores(true);
TermQuery query = new TermQuery(new Term("Category", "Cat 1"));
var groupsResult = groupingSearch.Search(indexSearcher, query, 0, 10); //search(indexSearcher, query, groupOffset, groupLimit);
indexReader.Dispose();
}
public static Filter GetFilterForRole(string role)
{
Filter roleFilter = RoleFilterCache.Get(role);
if (roleFilter == null)
{
roleFilter =
// the caching wrapper filter makes it cache the BitSet per segmentreader
new CachingWrapperFilter(
// builds the filter from the index and not from iterating
// stored doc content which is much faster
new QueryWrapperFilter(
new TermQuery(
new Term("security", role)
)
)
);
// put in cache
RoleFilterCache.Put(role, roleFilter);
}
return(roleFilter);
}
/// <summary>
/// Creates facets.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="query">The query.</param>
private void CreateFacets(IndexReader reader, Query query)
{
var groups = new List <FacetGroup>();
var baseQueryFilter = new CachingWrapperFilter(new QueryWrapperFilter(query));
var baseDocIdSet = baseQueryFilter.GetDocIdSet(reader);
#region Subcategory filters
/*
* var catalogCriteria = Results.SearchCriteria as CatalogItemSearchCriteria;
* if (catalogCriteria != null && catalogCriteria.ChildCategoryFilters.Any())
* {
* var group = new FacetGroup("Subcategory");
* var groupCount = 0;
*
* foreach (var value in catalogCriteria.ChildCategoryFilters)
* {
* var q = LuceneQueryHelper.CreateQuery(catalogCriteria.OutlineField, value);
*
* if (q == null) continue;
*
* var queryFilter = new CachingWrapperFilter(new QueryWrapperFilter(q));
* var filterArray = queryFilter.GetDocIdSet(reader);
* var newCount = (int)CalculateFacetCount(baseDocIdSet, filterArray);
* if (newCount == 0) continue;
*
* var newFacet = new Facet(group, value.Code, value.Name, newCount);
* group.Facets.Add(newFacet);
* groupCount += newCount;
* }
*
* // Add only if items exist under
* if (groupCount > 0)
* {
* groups.Add(group);
* }
* }
* */
#endregion
if (Results.SearchCriteria.Filters != null && Results.SearchCriteria.Filters.Length > 0)
{
foreach (var filter in Results.SearchCriteria.Filters)
{
if (!string.IsNullOrEmpty(Results.SearchCriteria.Currency) && filter is PriceRangeFilter)
{
var valCurrency = ((PriceRangeFilter)filter).Currency;
if (!valCurrency.Equals(Results.SearchCriteria.Currency, StringComparison.OrdinalIgnoreCase))
{
continue;
}
}
var facetGroup = CalculateResultCount(reader, baseDocIdSet, filter, Results.SearchCriteria);
if (facetGroup != null)
{
groups.Add(facetGroup);
}
}
}
Results.FacetGroups = groups.ToArray();
}
/// <summary>
/// Creates facets.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="query">The query.</param>
private void CreateFacets(IndexReader reader, Query query)
{
var groups = new List<FacetGroup>();
var baseQueryFilter = new CachingWrapperFilter(new QueryWrapperFilter(query));
var baseDocIdSet = baseQueryFilter.GetDocIdSet(reader);
#region Subcategory filters
/*
var catalogCriteria = Results.SearchCriteria as CatalogItemSearchCriteria;
if (catalogCriteria != null && catalogCriteria.ChildCategoryFilters.Any())
{
var group = new FacetGroup("Subcategory");
var groupCount = 0;
foreach (var value in catalogCriteria.ChildCategoryFilters)
{
var q = LuceneQueryHelper.CreateQuery(catalogCriteria.OutlineField, value);
if (q == null) continue;
var queryFilter = new CachingWrapperFilter(new QueryWrapperFilter(q));
var filterArray = queryFilter.GetDocIdSet(reader);
var newCount = (int)CalculateFacetCount(baseDocIdSet, filterArray);
if (newCount == 0) continue;
var newFacet = new Facet(group, value.Code, value.Name, newCount);
group.Facets.Add(newFacet);
groupCount += newCount;
}
// Add only if items exist under
if (groupCount > 0)
{
groups.Add(group);
}
}
* */
#endregion
if (Results.SearchCriteria.Filters != null && Results.SearchCriteria.Filters.Length > 0)
{
foreach (var filter in Results.SearchCriteria.Filters)
{
var group = new FacetGroup(filter.Key);
var groupCount = 0;
if (!String.IsNullOrEmpty(Results.SearchCriteria.Currency) && filter is s.PriceRangeFilter)
{
var valCurrency = ((s.PriceRangeFilter) filter).Currency;
if (
!valCurrency.Equals(
Results.SearchCriteria.Currency, StringComparison.OrdinalIgnoreCase))
{
continue;
}
}
groupCount += CalculateResultCount(reader, baseDocIdSet, group, filter,
Results.SearchCriteria);
// Add only if items exist under
if (groupCount > 0)
{
groups.Add(group);
}
}
}
Results.FacetGroups = groups.ToArray();
}
public virtual void TestBasic()
{
string groupField = "author";
FieldType customType = new FieldType();
customType.IsStored = (true);
Directory dir = NewDirectory();
RandomIndexWriter w = new RandomIndexWriter(
Random,
dir,
NewIndexWriterConfig(TEST_VERSION_CURRENT,
new MockAnalyzer(Random)).SetMergePolicy(NewLogMergePolicy()));
bool canUseIDV = !"Lucene3x".Equals(w.IndexWriter.Config.Codec.Name, StringComparison.Ordinal);
JCG.List <Document> documents = new JCG.List <Document>();
// 0
Document doc = new Document();
AddGroupField(doc, groupField, "author1", canUseIDV);
doc.Add(new TextField("content", "random text", Field.Store.YES));
doc.Add(new Field("id", "1", customType));
documents.Add(doc);
// 1
doc = new Document();
AddGroupField(doc, groupField, "author1", canUseIDV);
doc.Add(new TextField("content", "some more random text", Field.Store.YES));
doc.Add(new Field("id", "2", customType));
documents.Add(doc);
// 2
doc = new Document();
AddGroupField(doc, groupField, "author1", canUseIDV);
doc.Add(new TextField("content", "some more random textual data", Field.Store.YES));
doc.Add(new Field("id", "3", customType));
doc.Add(new StringField("groupend", "x", Field.Store.NO));
documents.Add(doc);
w.AddDocuments(documents);
documents.Clear();
// 3
doc = new Document();
AddGroupField(doc, groupField, "author2", canUseIDV);
doc.Add(new TextField("content", "some random text", Field.Store.YES));
doc.Add(new Field("id", "4", customType));
doc.Add(new StringField("groupend", "x", Field.Store.NO));
w.AddDocument(doc);
// 4
doc = new Document();
AddGroupField(doc, groupField, "author3", canUseIDV);
doc.Add(new TextField("content", "some more random text", Field.Store.YES));
doc.Add(new Field("id", "5", customType));
documents.Add(doc);
// 5
doc = new Document();
AddGroupField(doc, groupField, "author3", canUseIDV);
doc.Add(new TextField("content", "random", Field.Store.YES));
doc.Add(new Field("id", "6", customType));
doc.Add(new StringField("groupend", "x", Field.Store.NO));
documents.Add(doc);
w.AddDocuments(documents);
documents.Clear();
// 6 -- no author field
doc = new Document();
doc.Add(new TextField("content", "random word stuck in alot of other text", Field.Store.YES));
doc.Add(new Field("id", "6", customType));
doc.Add(new StringField("groupend", "x", Field.Store.NO));
w.AddDocument(doc);
IndexSearcher indexSearcher = NewSearcher(w.GetReader());
w.Dispose();
Sort groupSort = Sort.RELEVANCE;
GroupingSearch groupingSearch = CreateRandomGroupingSearch(groupField, groupSort, 5, canUseIDV);
ITopGroups <object> groups = groupingSearch.Search(indexSearcher, (Filter)null, new TermQuery(new Index.Term("content", "random")), 0, 10);
assertEquals(7, groups.TotalHitCount);
assertEquals(7, groups.TotalGroupedHitCount);
assertEquals(4, groups.Groups.Length);
// relevance order: 5, 0, 3, 4, 1, 2, 6
// the later a document is added the higher this docId
// value
IGroupDocs <object> group = groups.Groups[0];
CompareGroupValue("author3", group);
assertEquals(2, group.ScoreDocs.Length);
assertEquals(5, group.ScoreDocs[0].Doc);
assertEquals(4, group.ScoreDocs[1].Doc);
assertTrue(group.ScoreDocs[0].Score > group.ScoreDocs[1].Score);
group = groups.Groups[1];
CompareGroupValue("author1", group);
assertEquals(3, group.ScoreDocs.Length);
assertEquals(0, group.ScoreDocs[0].Doc);
assertEquals(1, group.ScoreDocs[1].Doc);
assertEquals(2, group.ScoreDocs[2].Doc);
assertTrue(group.ScoreDocs[0].Score > group.ScoreDocs[1].Score);
assertTrue(group.ScoreDocs[1].Score > group.ScoreDocs[2].Score);
group = groups.Groups[2];
CompareGroupValue("author2", group);
assertEquals(1, group.ScoreDocs.Length);
assertEquals(3, group.ScoreDocs[0].Doc);
group = groups.Groups[3];
CompareGroupValue(null, group);
assertEquals(1, group.ScoreDocs.Length);
assertEquals(6, group.ScoreDocs[0].Doc);
Filter lastDocInBlock = new CachingWrapperFilter(new QueryWrapperFilter(new TermQuery(new Index.Term("groupend", "x"))));
groupingSearch = new GroupingSearch(lastDocInBlock);
groups = groupingSearch.Search(indexSearcher, null, new TermQuery(new Index.Term("content", "random")), 0, 10);
assertEquals(7, groups.TotalHitCount);
assertEquals(7, groups.TotalGroupedHitCount);
assertEquals(4, groups.TotalGroupCount.GetValueOrDefault());
assertEquals(4, groups.Groups.Length);
indexSearcher.IndexReader.Dispose();
dir.Dispose();
}
/// <summary>
/// Creates facets.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="query">The query.</param>
private void CreateFacets(IndexReader reader, Query query)
{
var groups = new List<FacetGroup>();
if (this.Results.SearchCriteria.Filters != null && this.Results.SearchCriteria.Filters.Length > 0)
{
var baseQueryFilter = new CachingWrapperFilter(new QueryWrapperFilter(query));
var baseBitArray = baseQueryFilter.GetDocIdSet(reader);
foreach (var filter in this.Results.SearchCriteria.Filters)
{
var group = new FacetGroup(filter.Key);
var groupCount = 0;
if (!String.IsNullOrEmpty(this.Results.SearchCriteria.Currency) && filter is s.PriceRangeFilter)
{
var valCurrency = ((s.PriceRangeFilter)filter).Currency;
if (
!valCurrency.Equals(
this.Results.SearchCriteria.Currency, StringComparison.OrdinalIgnoreCase))
{
continue;
}
}
groupCount += this.CalculateResultCount(
reader, baseBitArray, group, filter, this.Results.SearchCriteria.Currency);
// Add only if items exist under
if (groupCount > 0)
{
groups.Add(group);
}
}
}
this.Results.FacetGroups = groups.ToArray();
}
public IEnumerable <IHit> Query(int pageIndex, int pageSize, out int totalCount, out IEnumerable <FacetGroup> facetedResults)
{
totalCount = 0;
facetedResults = null;
if (searchPaths == null || searchPaths.Count <= 0)
{
searchPaths.AddRange(indexPaths.Values.Select(o => o.Path));
}
List <LuceneHit> results = new List <LuceneHit>();
List <IndexSearcher> subSearchs = new List <IndexSearcher>();
searchPaths.ForEach(o => subSearchs.Add(new IndexSearcher(FSDirectory.Open(o))));
if (facetFields != null && facetFields.Count > 0)
{
var facetGroups = new List <FacetGroup>();
var mainQueryFilter = new CachingWrapperFilter(new QueryWrapperFilter(query));
MultiReader readers = new MultiReader(subSearchs.Select(o => o.IndexReader).ToArray());
foreach (var facetField in facetFields)
{
FacetGroup fg = new FacetGroup();
fg.FieldName = facetFieldNameProvider.GetMapName(TypeName, facetField);
var items = new List <FacetItem>();
var allDistinctField = FieldCache_Fields.DEFAULT.GetStrings(readers, facetField).Distinct().ToArray();
int totalHits = 0;
Parallel.ForEach(allDistinctField, fieldValue =>
{
//foreach (var fieldValue in allDistinctField)
//{
var facetQuery = new TermQuery(new Term(facetField, fieldValue));
var facetQueryFilter = new CachingWrapperFilter(new QueryWrapperFilter(facetQuery));
var bs = new OpenBitSetDISI(facetQueryFilter.GetDocIdSet(readers).Iterator(), readers.MaxDoc);
bs.InPlaceAnd(mainQueryFilter.GetDocIdSet(readers).Iterator());
int count = (Int32)bs.Cardinality();
FacetItem item = new FacetItem();
item.GroupValue = fieldValue;
item.Count = count;
items.Add(item);
totalHits += count;
}
);
fg.FacetItems = items.OrderByDescending(o => o.Count);
fg.TotalHits = totalHits;
facetGroups.Add(fg);
}
facetedResults = facetGroups.OrderBy(o => o.FieldName);
}
ParallelMultiSearcher searcher = new ParallelMultiSearcher(subSearchs.ToArray());
Sort sort = null;
if (sortFields != null && sortFields.Count > 0)
{
sort = new Sort(sortFields.ToArray());
}
int maxDoc = searcher.MaxDoc;
int startIndex = 0;
if (pageIndex >= 0 && pageSize > 0)
{
startIndex = pageIndex * pageSize;
maxDoc = pageSize * (pageIndex + 1);
}
var docs = sort == null?searcher.Search(query, null, maxDoc) : searcher.Search(query, null, maxDoc, sort);
totalCount = docs.TotalHits;
int endIndex = docs.TotalHits - startIndex;
for (int i = startIndex; i < endIndex; i++)
{
LuceneHit h = new LuceneHit(TypeName, DocumentBuilder, searcher.Doc(docs.ScoreDocs[i].Doc));
results.Add(h);
}
return(results);
}
/// <summary>
/// Calculates the result count.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="baseDocIdSet">The base doc id set.</param>
/// <param name="facetGroup">The facet group.</param>
/// <param name="filter">The filter.</param>
/// <param name="currency">The currency.</param>
/// <returns></returns>
private int CalculateResultCount(
IndexReader reader, DocIdSet baseDocIdSet, FacetGroup facetGroup, ISearchFilter filter, string currency)
{
var count = 0;
ISearchFilterValue[] values = null;
var priceQuery = false;
if (filter is s.AttributeFilter)
{
values = ((s.AttributeFilter)filter).Values;
}
else if (filter is s.RangeFilter)
{
values = ((s.RangeFilter)filter).Values;
}
else if (filter is s.PriceRangeFilter)
{
values = ((s.PriceRangeFilter)filter).Values;
priceQuery = true;
}
if (values == null)
{
return 0;
}
foreach (var value in values)
{
Query q = null;
if (priceQuery)
{
q = LuceneQueryHelper.CreateQuery(
this.Results.SearchCriteria, filter.Key, value as s.RangeFilterValue);
}
else
{
q = LuceneQueryHelper.CreateQuery(filter.Key, value);
}
if (q == null) continue;
var queryFilter = new CachingWrapperFilter(new QueryWrapperFilter(q));
var filterArray = queryFilter.GetDocIdSet(reader);
var newCount = (int)this.CalculateFacetCount(baseDocIdSet, filterArray);
if (newCount == 0) continue;
var newFacet = new Facet(facetGroup, value.Id, this.GetDescription(value, this.Results.SearchCriteria.Locale), newCount);
facetGroup.Facets.Add(newFacet);
count += newCount;
}
return count;
}
public virtual void TestBasic()
{
string groupField = "author";
FieldType customType = new FieldType();
customType.Stored = (true);
Directory dir = NewDirectory();
RandomIndexWriter w = new RandomIndexWriter(
Random(),
dir,
NewIndexWriterConfig(TEST_VERSION_CURRENT,
new MockAnalyzer(Random())).SetMergePolicy(NewLogMergePolicy()));
bool canUseIDV = !"Lucene3x".Equals(w.w.Config.Codec.Name, StringComparison.Ordinal);
List<Document> documents = new List<Document>();
// 0
Document doc = new Document();
AddGroupField(doc, groupField, "author1", canUseIDV);
doc.Add(new TextField("content", "random text", Field.Store.YES));
doc.Add(new Field("id", "1", customType));
documents.Add(doc);
// 1
doc = new Document();
AddGroupField(doc, groupField, "author1", canUseIDV);
doc.Add(new TextField("content", "some more random text", Field.Store.YES));
doc.Add(new Field("id", "2", customType));
documents.Add(doc);
// 2
doc = new Document();
AddGroupField(doc, groupField, "author1", canUseIDV);
doc.Add(new TextField("content", "some more random textual data", Field.Store.YES));
doc.Add(new Field("id", "3", customType));
doc.Add(new StringField("groupend", "x", Field.Store.NO));
documents.Add(doc);
w.AddDocuments(documents);
documents.Clear();
// 3
doc = new Document();
AddGroupField(doc, groupField, "author2", canUseIDV);
doc.Add(new TextField("content", "some random text", Field.Store.YES));
doc.Add(new Field("id", "4", customType));
doc.Add(new StringField("groupend", "x", Field.Store.NO));
w.AddDocument(doc);
// 4
doc = new Document();
AddGroupField(doc, groupField, "author3", canUseIDV);
doc.Add(new TextField("content", "some more random text", Field.Store.YES));
doc.Add(new Field("id", "5", customType));
documents.Add(doc);
// 5
doc = new Document();
AddGroupField(doc, groupField, "author3", canUseIDV);
doc.Add(new TextField("content", "random", Field.Store.YES));
doc.Add(new Field("id", "6", customType));
doc.Add(new StringField("groupend", "x", Field.Store.NO));
documents.Add(doc);
w.AddDocuments(documents);
documents.Clear();
// 6 -- no author field
doc = new Document();
doc.Add(new TextField("content", "random word stuck in alot of other text", Field.Store.YES));
doc.Add(new Field("id", "6", customType));
doc.Add(new StringField("groupend", "x", Field.Store.NO));
w.AddDocument(doc);
IndexSearcher indexSearcher = NewSearcher(w.Reader);
w.Dispose();
Sort groupSort = Sort.RELEVANCE;
GroupingSearch groupingSearch = CreateRandomGroupingSearch(groupField, groupSort, 5, canUseIDV);
ITopGroups<object> groups = groupingSearch.Search(indexSearcher, (Filter)null, new TermQuery(new Index.Term("content", "random")), 0, 10);
assertEquals(7, groups.TotalHitCount);
assertEquals(7, groups.TotalGroupedHitCount);
assertEquals(4, groups.Groups.Length);
// relevance order: 5, 0, 3, 4, 1, 2, 6
// the later a document is added the higher this docId
// value
IGroupDocs<object> group = groups.Groups[0];
CompareGroupValue("author3", group);
assertEquals(2, group.ScoreDocs.Length);
assertEquals(5, group.ScoreDocs[0].Doc);
assertEquals(4, group.ScoreDocs[1].Doc);
assertTrue(group.ScoreDocs[0].Score > group.ScoreDocs[1].Score);
group = groups.Groups[1];
CompareGroupValue("author1", group);
assertEquals(3, group.ScoreDocs.Length);
assertEquals(0, group.ScoreDocs[0].Doc);
assertEquals(1, group.ScoreDocs[1].Doc);
assertEquals(2, group.ScoreDocs[2].Doc);
assertTrue(group.ScoreDocs[0].Score > group.ScoreDocs[1].Score);
assertTrue(group.ScoreDocs[1].Score > group.ScoreDocs[2].Score);
group = groups.Groups[2];
CompareGroupValue("author2", group);
assertEquals(1, group.ScoreDocs.Length);
assertEquals(3, group.ScoreDocs[0].Doc);
group = groups.Groups[3];
CompareGroupValue(null, group);
assertEquals(1, group.ScoreDocs.Length);
assertEquals(6, group.ScoreDocs[0].Doc);
Filter lastDocInBlock = new CachingWrapperFilter(new QueryWrapperFilter(new TermQuery(new Index.Term("groupend", "x"))));
groupingSearch = new GroupingSearch(lastDocInBlock);
groups = groupingSearch.Search(indexSearcher, null, new TermQuery(new Index.Term("content", "random")), 0, 10);
assertEquals(7, groups.TotalHitCount);
assertEquals(7, groups.TotalGroupedHitCount);
assertEquals(4, groups.TotalGroupCount.GetValueOrDefault());
assertEquals(4, groups.Groups.Length);
indexSearcher.IndexReader.Dispose();
dir.Dispose();
}
