public virtual void TestThousandDocuments()
{
Directory dir = NewDirectory();
RandomIndexWriter writer = new RandomIndexWriter(Random(), dir, Similarity, TimeZone);
for (int i = 0; i < 1000; i++)
{
Document doc = new Document();
doc.Add(NewStringField("field", English.IntToEnglish(i), Field.Store.NO));
writer.AddDocument(doc);
}
IndexReader reader = writer.Reader;
writer.Dispose();
IndexSearcher searcher = NewSearcher(reader);
for (int i = 0; i < 1000; i++)
{
TermQuery termQuery = new TermQuery(new Term("field", English.IntToEnglish(i)));
QueryWrapperFilter qwf = new QueryWrapperFilter(termQuery);
TopDocs td = searcher.Search(new MatchAllDocsQuery(), qwf, 10);
Assert.AreEqual(1, td.TotalHits);
}
reader.Dispose();
dir.Dispose();
}
public virtual void TestThousandDocuments()
{
Directory dir = NewDirectory();
RandomIndexWriter writer = new RandomIndexWriter(
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
this,
#endif
Random, dir);
for (int i = 0; i < 1000; i++)
{
Document doc = new Document();
doc.Add(NewStringField("field", English.Int32ToEnglish(i), Field.Store.NO));
writer.AddDocument(doc);
}
IndexReader reader = writer.GetReader();
writer.Dispose();
IndexSearcher searcher = NewSearcher(reader);
for (int i = 0; i < 1000; i++)
{
TermQuery termQuery = new TermQuery(new Term("field", English.Int32ToEnglish(i)));
QueryWrapperFilter qwf = new QueryWrapperFilter(termQuery);
TopDocs td = searcher.Search(new MatchAllDocsQuery(), qwf, 10);
Assert.AreEqual(1, td.TotalHits);
}
reader.Dispose();
dir.Dispose();
}
private static IList<int> SearchCore(SearchFilter searchFilter, out int totalHits)
{
if (!Directory.Exists(LuceneCommon.IndexDirectory))
{
totalHits = 0;
return new int[0];
}
SortField sortField = GetSortField(searchFilter);
int numRecords = searchFilter.Skip + searchFilter.Take;
using (var directory = new LuceneFileSystem(LuceneCommon.IndexDirectory))
{
var searcher = new IndexSearcher(directory, readOnly: true);
var query = ParseQuery(searchFilter);
var filterTerm = searchFilter.IncludePrerelease ? "IsLatest" : "IsLatestStable";
var termQuery = new TermQuery(new Term(filterTerm, Boolean.TrueString));
Filter filter = new QueryWrapperFilter(termQuery);
var results = searcher.Search(query, filter: filter, n: numRecords, sort: new Sort(sortField));
var keys = results.scoreDocs.Skip(searchFilter.Skip)
.Select(c => ParseKey(searcher.Doc(c.doc).Get("Key")))
.ToList();
totalHits = results.totalHits;
searcher.Close();
return keys;
}
}
public virtual void TestBasic()
{
Directory dir = new RAMDirectory();
IndexWriter writer = new IndexWriter(dir, new StandardAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
Document doc = new Document();
doc.Add(new Field("field", "value", Field.Store.NO, Field.Index.ANALYZED));
writer.AddDocument(doc);
writer.Close();
TermQuery termQuery = new TermQuery(new Term("field", "value"));
// should not throw exception with primitive query
QueryWrapperFilter qwf = new QueryWrapperFilter(termQuery);
IndexSearcher searcher = new IndexSearcher(dir, true);
TopDocs hits = searcher.Search(new MatchAllDocsQuery(), qwf, 10);
Assert.AreEqual(1, hits.totalHits);
// should not throw exception with complex primitive query
BooleanQuery booleanQuery = new BooleanQuery();
booleanQuery.Add(termQuery, Occur.MUST);
booleanQuery.Add(new TermQuery(new Term("field", "missing")), Occur.MUST_NOT);
qwf = new QueryWrapperFilter(termQuery);
hits = searcher.Search(new MatchAllDocsQuery(), qwf, 10);
Assert.AreEqual(1, hits.totalHits);
// should not throw exception with non primitive Query (doesn't implement
// Query#createWeight)
qwf = new QueryWrapperFilter(new FuzzyQuery(new Term("field", "valu")));
hits = searcher.Search(new MatchAllDocsQuery(), qwf, 10);
Assert.AreEqual(1, hits.totalHits);
}
public DocIdSetAnonymousInnerClassHelper(QueryWrapperFilter outerInstance, Bits acceptDocs, AtomicReaderContext privateContext, Lucene.Net.Search.Weight weight)
{
this.OuterInstance = outerInstance;
this.AcceptDocs = acceptDocs;
this.PrivateContext = privateContext;
this.Weight = weight;
}
public DocIdSetAnonymousInnerClassHelper(QueryWrapperFilter outerInstance, IBits acceptDocs, AtomicReaderContext privateContext, Lucene.Net.Search.Weight weight)
{
this.outerInstance = outerInstance;
this.acceptDocs = acceptDocs;
this.privateContext = privateContext;
this.weight = weight;
}
public override Query Rewrite(IndexReader reader)
{
if (m_query != null)
{
Query rewritten = m_query.Rewrite(reader);
if (rewritten != m_query)
{
rewritten = new ConstantScoreQuery(rewritten);
rewritten.Boost = this.Boost;
return(rewritten);
}
}
else
{
if (Debugging.AssertsEnabled)
{
Debugging.Assert(m_filter != null);
}
// Fix outdated usage pattern from Lucene 2.x/early-3.x:
// because ConstantScoreQuery only accepted filters,
// QueryWrapperFilter was used to wrap queries.
if (m_filter is QueryWrapperFilter)
{
QueryWrapperFilter qwf = (QueryWrapperFilter)m_filter;
Query rewritten = new ConstantScoreQuery(qwf.Query.Rewrite(reader));
rewritten.Boost = this.Boost;
return(rewritten);
}
}
return(this);
}
private IQueryable<Package> SearchCore(SearchFilter searchFilter, out int totalHits)
{
int numRecords = searchFilter.Skip + searchFilter.Take;
var searcher = new IndexSearcher(_directory, readOnly: true);
var query = ParseQuery(searchFilter);
// IF searching by relevance, boost scores by download count.
if (searchFilter.SortProperty == SortProperty.Relevance)
{
var downloadCountBooster = new FieldScoreQuery("DownloadCount", FieldScoreQuery.Type.INT);
query = new CustomScoreQuery(query, downloadCountBooster);
}
var filterTerm = searchFilter.IncludePrerelease ? "IsLatest" : "IsLatestStable";
var termQuery = new TermQuery(new Term(filterTerm, Boolean.TrueString));
var filter = new QueryWrapperFilter(termQuery);
var results = searcher.Search(query, filter: filter, n: numRecords, sort: new Sort(GetSortField(searchFilter)));
totalHits = results.totalHits;
if (results.totalHits == 0 || searchFilter.CountOnly)
{
return Enumerable.Empty<Package>().AsQueryable();
}
var packages = results.scoreDocs
.Skip(searchFilter.Skip)
.Select(sd => PackageFromDoc(searcher.Doc(sd.doc)))
.ToList();
return packages.AsQueryable();
}
public virtual void TestQueryWrapperFilter()
{
Directory d = NewDirectory();
RandomIndexWriter w = new RandomIndexWriter(Random, d, Similarity, TimeZone);
Document doc = new Document();
doc.Add(NewStringField("field", "a", Field.Store.NO));
w.AddDocument(doc);
IndexReader r = w.GetReader();
w.Dispose();
Filter filter = new QueryWrapperFilter(AssertingQuery.Wrap(Random, new TermQuery(new Term("field", "a"))));
IndexSearcher s = NewSearcher(r);
Debug.Assert(s is AssertingIndexSearcher);
// this used to fail
s.Search(new ConstantScoreQuery(filter), new TotalHitCountCollector());
// check the rewrite
Query rewritten = (new ConstantScoreQuery(filter)).Rewrite(r);
Assert.IsTrue(rewritten is ConstantScoreQuery);
Assert.IsTrue(((ConstantScoreQuery)rewritten).Query is AssertingQuery);
r.Dispose();
d.Dispose();
}
public virtual void TestQueryWrapperFilter()
{
Directory d = NewDirectory();
RandomIndexWriter w = new RandomIndexWriter(
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
this,
#endif
Random, d);
Document doc = new Document();
doc.Add(NewStringField("field", "a", Field.Store.NO));
w.AddDocument(doc);
IndexReader r = w.GetReader();
w.Dispose();
Filter filter = new QueryWrapperFilter(AssertingQuery.Wrap(Random, new TermQuery(new Term("field", "a"))));
IndexSearcher s = NewSearcher(r);
if (Debugging.AssertsEnabled)
{
Debugging.Assert(s is AssertingIndexSearcher);
}
// this used to fail
s.Search(new ConstantScoreQuery(filter), new TotalHitCountCollector());
// check the rewrite
Query rewritten = (new ConstantScoreQuery(filter)).Rewrite(r);
Assert.IsTrue(rewritten is ConstantScoreQuery);
Assert.IsTrue(((ConstantScoreQuery)rewritten).Query is AssertingQuery);
r.Dispose();
d.Dispose();
}
public virtual void TestQueries()
{
// LUCENENET specific: NUnit will crash with an OOM if we do the full test
// with verbosity enabled. So, making this a manual setting that can be
// turned on if, and only if, needed for debugging. If the setting is turned
// on, we are decresing the number of iterations to only 1, which seems to
// keep it from crashing.
// Enable verbosity at the top of this file: isVerbose = true;
// because the first page has a null 'after', we get a normal collector.
// so we need to run the test a few times to ensure we will collect multiple
// pages.
int n = isVerbose ? 1 : AtLeast(20);
for (int i = 0; i < n; i++)
{
Filter odd = new QueryWrapperFilter(new TermQuery(new Term("oddeven", "odd")));
AssertQuery(new MatchAllDocsQuery(), null);
AssertQuery(new TermQuery(new Term("english", "one")), null);
AssertQuery(new MatchAllDocsQuery(), odd);
AssertQuery(new TermQuery(new Term("english", "four")), odd);
BooleanQuery bq = new BooleanQuery();
bq.Add(new TermQuery(new Term("english", "one")), Occur.SHOULD);
bq.Add(new TermQuery(new Term("oddeven", "even")), Occur.SHOULD);
AssertQuery(bq, null);
}
}
public virtual void TestBasic()
{
Directory dir = NewDirectory();
RandomIndexWriter writer = new RandomIndexWriter(
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
this,
#endif
Random, dir);
Document doc = new Document();
doc.Add(NewTextField("field", "value", Field.Store.NO));
writer.AddDocument(doc);
IndexReader reader = writer.GetReader();
writer.Dispose();
TermQuery termQuery = new TermQuery(new Term("field", "value"));
// should not throw exception with primitive query
QueryWrapperFilter qwf = new QueryWrapperFilter(termQuery);
IndexSearcher searcher = NewSearcher(reader);
TopDocs hits = searcher.Search(new MatchAllDocsQuery(), qwf, 10);
Assert.AreEqual(1, hits.TotalHits);
hits = searcher.Search(new MatchAllDocsQuery(), new CachingWrapperFilter(qwf), 10);
Assert.AreEqual(1, hits.TotalHits);
// should not throw exception with complex primitive query
BooleanQuery booleanQuery = new BooleanQuery();
booleanQuery.Add(termQuery, Occur.MUST);
booleanQuery.Add(new TermQuery(new Term("field", "missing")), Occur.MUST_NOT);
qwf = new QueryWrapperFilter(termQuery);
hits = searcher.Search(new MatchAllDocsQuery(), qwf, 10);
Assert.AreEqual(1, hits.TotalHits);
hits = searcher.Search(new MatchAllDocsQuery(), new CachingWrapperFilter(qwf), 10);
Assert.AreEqual(1, hits.TotalHits);
// should not throw exception with non primitive Query (doesn't implement
// Query#createWeight)
qwf = new QueryWrapperFilter(new FuzzyQuery(new Term("field", "valu")));
hits = searcher.Search(new MatchAllDocsQuery(), qwf, 10);
Assert.AreEqual(1, hits.TotalHits);
hits = searcher.Search(new MatchAllDocsQuery(), new CachingWrapperFilter(qwf), 10);
Assert.AreEqual(1, hits.TotalHits);
// test a query with no hits
termQuery = new TermQuery(new Term("field", "not_exist"));
qwf = new QueryWrapperFilter(termQuery);
hits = searcher.Search(new MatchAllDocsQuery(), qwf, 10);
Assert.AreEqual(0, hits.TotalHits);
hits = searcher.Search(new MatchAllDocsQuery(), new CachingWrapperFilter(qwf), 10);
Assert.AreEqual(0, hits.TotalHits);
reader.Dispose();
dir.Dispose();
}
public virtual void TestDense()
{
Query query = new MatchAllDocsQuery();
Filter expected = new QueryWrapperFilter(query);
Filter actual = new CachingWrapperFilter(expected);
AssertFilterEquals(expected, actual);
}
public virtual void TestEmpty()
{
Query query = new BooleanQuery();
Filter expected = new QueryWrapperFilter(query);
Filter actual = new CachingWrapperFilter(expected);
AssertFilterEquals(expected, actual);
}
public virtual void TestEmpty2()
{
BooleanQuery query = new BooleanQuery();
query.Add(new TermQuery(new Term("id", "0")), Occur.MUST);
query.Add(new TermQuery(new Term("id", "0")), Occur.MUST_NOT);
Filter expected = new QueryWrapperFilter(query);
Filter actual = new CachingWrapperFilter(expected);
AssertFilterEquals(expected, actual);
}
public virtual void TestSingle()
{
for (int i = 0; i < 10; i++)
{
int id = Random.Next(ir.MaxDoc);
Query query = new TermQuery(new Term("id", Convert.ToString(id)));
Filter expected = new QueryWrapperFilter(query);
Filter actual = new CachingWrapperFilter(expected);
AssertFilterEquals(expected, actual);
}
}
public virtual void TestSparse()
{
for (int i = 0; i < 10; i++)
{
int id_start = Random.Next(ir.MaxDoc - 1);
int id_end = id_start + 1;
Query query = TermRangeQuery.NewStringRange("id", Convert.ToString(id_start), Convert.ToString(id_end), true, true);
Filter expected = new QueryWrapperFilter(query);
Filter actual = new CachingWrapperFilter(expected);
AssertFilterEquals(expected, actual);
}
}
public virtual void TestBasic()
{
Directory dir = NewDirectory();
RandomIndexWriter writer = new RandomIndexWriter(Random(), dir);
Document doc = new Document();
doc.Add(NewTextField("field", "value", Field.Store.NO));
writer.AddDocument(doc);
IndexReader reader = writer.Reader;
writer.Dispose();
TermQuery termQuery = new TermQuery(new Term("field", "value"));
// should not throw exception with primitive query
QueryWrapperFilter qwf = new QueryWrapperFilter(termQuery);
IndexSearcher searcher = NewSearcher(reader);
TopDocs hits = searcher.Search(new MatchAllDocsQuery(), qwf, 10);
Assert.AreEqual(1, hits.TotalHits);
hits = searcher.Search(new MatchAllDocsQuery(), new CachingWrapperFilter(qwf), 10);
Assert.AreEqual(1, hits.TotalHits);
// should not throw exception with complex primitive query
BooleanQuery booleanQuery = new BooleanQuery();
booleanQuery.Add(termQuery, Occur.MUST);
booleanQuery.Add(new TermQuery(new Term("field", "missing")), Occur.MUST_NOT);
qwf = new QueryWrapperFilter(termQuery);
hits = searcher.Search(new MatchAllDocsQuery(), qwf, 10);
Assert.AreEqual(1, hits.TotalHits);
hits = searcher.Search(new MatchAllDocsQuery(), new CachingWrapperFilter(qwf), 10);
Assert.AreEqual(1, hits.TotalHits);
// should not throw exception with non primitive Query (doesn't implement
// Query#createWeight)
qwf = new QueryWrapperFilter(new FuzzyQuery(new Term("field", "valu")));
hits = searcher.Search(new MatchAllDocsQuery(), qwf, 10);
Assert.AreEqual(1, hits.TotalHits);
hits = searcher.Search(new MatchAllDocsQuery(), new CachingWrapperFilter(qwf), 10);
Assert.AreEqual(1, hits.TotalHits);
// test a query with no hits
termQuery = new TermQuery(new Term("field", "not_exist"));
qwf = new QueryWrapperFilter(termQuery);
hits = searcher.Search(new MatchAllDocsQuery(), qwf, 10);
Assert.AreEqual(0, hits.TotalHits);
hits = searcher.Search(new MatchAllDocsQuery(), new CachingWrapperFilter(qwf), 10);
Assert.AreEqual(0, hits.TotalHits);
reader.Dispose();
dir.Dispose();
}
private SearchResults SearchCore(SearchFilter searchFilter)
{
// Get index timestamp
DateTime timestamp = File.GetLastWriteTimeUtc(LuceneCommon.GetIndexMetadataPath());
int numRecords = searchFilter.Skip + searchFilter.Take;
var searcher = new IndexSearcher(_directory, readOnly: true);
var query = ParseQuery(searchFilter);
// IF searching by relevance, boost scores by download count.
if (searchFilter.SortOrder == SortOrder.Relevance)
{
var downloadCountBooster = new FieldScoreQuery("DownloadCount", FieldScoreQuery.Type.INT);
query = new CustomScoreQuery(query, downloadCountBooster);
}
var filterTerm = searchFilter.IncludePrerelease ? "IsLatest" : "IsLatestStable";
Query filterQuery = new TermQuery(new Term(filterTerm, Boolean.TrueString));
if (searchFilter.CuratedFeed != null)
{
var feedFilterQuery = new TermQuery(new Term("CuratedFeedKey", searchFilter.CuratedFeed.Key.ToString(CultureInfo.InvariantCulture)));
BooleanQuery conjunctionQuery = new BooleanQuery();
conjunctionQuery.Add(filterQuery, Occur.MUST);
conjunctionQuery.Add(feedFilterQuery, Occur.MUST);
filterQuery = conjunctionQuery;
}
Filter filter = new QueryWrapperFilter(filterQuery);
var results = searcher.Search(query, filter: filter, n: numRecords, sort: new Sort(GetSortField(searchFilter)));
if (results.TotalHits == 0 || searchFilter.CountOnly)
{
return new SearchResults(results.TotalHits, timestamp);
}
var packages = results.ScoreDocs
.Skip(searchFilter.Skip)
.Select(sd => PackageFromDoc(searcher.Doc(sd.Doc)))
.ToList();
return new SearchResults(
results.TotalHits,
timestamp,
packages.AsQueryable());
}
public Task<IEnumerable<SearchResultItem>> SearchAsync(string searchText, int projectId)
{
return Task.Run(() =>
{
//new searcher each time,
// because they don't see commits from any writer after being opened.
// even in huge deployments though, TD's number of concurrent searches
// would be tiny... not worth coding a mechanism to detect updates and
// reuse a searcher until the index is updated. In actuality, index
// updates would certainly be more frequent than index searches.
var searcher = new IndexSearcher(TdIndexDirectory, true);
var fields = new[] {"id", "title", "details", "tags", "events"};
var parser = new MultiFieldQueryParser(Version.LUCENE_30,
fields,
TdIndexAnalyzer);
var query = parser.Parse(searchText);
var collector = TopScoreDocCollector.Create(20, true);
if (projectId != default(int))
{
var filterQuery = new BooleanQuery();
filterQuery.Add(new TermQuery(new Term("projectid", projectId.ToString())), Occur.MUST);
var filter = new QueryWrapperFilter(filterQuery);
searcher.Search(query, filter, collector);
}
else
{
searcher.Search(query, collector);
}
return collector.TopDocs().ScoreDocs.Select(d =>
{
var document = searcher.Doc(d.Doc);
return new SearchResultItem
{
Id = int.Parse(document.Get("id")),
SearchScore = d.Score
};
});
});
}
public virtual void TestQueries()
{
int n = AtLeast(4);
for (int i = 0; i < n; i++)
{
Filter odd = new QueryWrapperFilter(new TermQuery(new Term("oddeven", "odd")));
AssertQuery(new MatchAllDocsQuery(), null);
AssertQuery(new TermQuery(new Term("english", "one")), null);
AssertQuery(new MatchAllDocsQuery(), odd);
AssertQuery(new TermQuery(new Term("english", "four")), odd);
BooleanQuery bq = new BooleanQuery();
bq.Add(new TermQuery(new Term("english", "one")), BooleanClause.Occur.SHOULD);
bq.Add(new TermQuery(new Term("oddeven", "even")), BooleanClause.Occur.SHOULD);
AssertQuery(bq, null);
// force in order
bq.Add(new TermQuery(new Term("english", "two")), BooleanClause.Occur.SHOULD);
bq.MinimumNumberShouldMatch = 2;
AssertQuery(bq, null);
}
}
public virtual void TestQueries()
{
// because the first page has a null 'after', we get a normal collector.
// so we need to run the test a few times to ensure we will collect multiple
// pages.
int n = AtLeast(20);
for (int i = 0; i < n; i++)
{
Filter odd = new QueryWrapperFilter(new TermQuery(new Term("oddeven", "odd")));
AssertQuery(new MatchAllDocsQuery(), null);
AssertQuery(new TermQuery(new Term("english", "one")), null);
AssertQuery(new MatchAllDocsQuery(), odd);
AssertQuery(new TermQuery(new Term("english", "four")), odd);
BooleanQuery bq = new BooleanQuery();
bq.Add(new TermQuery(new Term("english", "one")), BooleanClause.Occur.SHOULD);
bq.Add(new TermQuery(new Term("oddeven", "even")), BooleanClause.Occur.SHOULD);
AssertQuery(bq, null);
}
}
private IQueryable<Package> SearchCore(SearchFilter searchFilter, out int totalHits)
{
int numRecords = searchFilter.Skip + searchFilter.Take;
var searcher = new IndexSearcher(_directory, readOnly: true);
var query = ParseQuery(searchFilter);
// IF searching by relevance, boost scores by download count.
if (searchFilter.SortProperty == SortProperty.Relevance)
{
var downloadCountBooster = new FieldScoreQuery("DownloadCount", FieldScoreQuery.Type.INT);
query = new CustomScoreQuery(query, downloadCountBooster);
}
var filterTerm = searchFilter.IncludePrerelease ? "IsLatest" : "IsLatestStable";
Query filterQuery = new TermQuery(new Term(filterTerm, Boolean.TrueString));
if (searchFilter.CuratedFeedKey.HasValue)
{
var feedFilterQuery = new TermQuery(new Term("CuratedFeedKey", searchFilter.CuratedFeedKey.Value.ToString(CultureInfo.InvariantCulture)));
BooleanQuery conjunctionQuery = new BooleanQuery();
conjunctionQuery.Add(filterQuery, Occur.MUST);
conjunctionQuery.Add(feedFilterQuery, Occur.MUST);
filterQuery = conjunctionQuery;
}
Filter filter = new QueryWrapperFilter(filterQuery);
var results = searcher.Search(query, filter: filter, n: numRecords, sort: new Sort(GetSortField(searchFilter)));
totalHits = results.TotalHits;
if (results.TotalHits == 0 || searchFilter.CountOnly)
{
return Enumerable.Empty<Package>().AsQueryable();
}
var packages = results.ScoreDocs
.Skip(searchFilter.Skip)
.Select(sd => PackageFromDoc(searcher.Doc(sd.Doc)))
.ToList();
return packages.AsQueryable();
}
public void SetUp()
{
directory = new RAMDirectory();
IndexWriter writer =
new IndexWriter(directory, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.UNLIMITED);
DateTime cal = new DateTime(1041397200000L * TimeSpan.TicksPerMillisecond); // 2003 January 01
for (int i = 0; i < MAX; i++)
{
Document doc = new Document();
doc.Add(new Field("key", "" + (i + 1), Field.Store.YES, Field.Index.NOT_ANALYZED));
doc.Add(new Field("owner", (i < MAX / 2) ? "bob" : "sue", Field.Store.YES, Field.Index.NOT_ANALYZED));
doc.Add(new Field("date", (cal.Ticks / TimeSpan.TicksPerMillisecond).ToString(), Field.Store.YES, Field.Index.NOT_ANALYZED));
writer.AddDocument(doc);
cal.AddMilliseconds(1);
}
writer.Close();
searcher = new IndexSearcher(directory, true);
// query for everything to make life easier
BooleanQuery bq = new BooleanQuery();
bq.Add(new TermQuery(new Term("owner", "bob")), BooleanClause.Occur.SHOULD);
bq.Add(new TermQuery(new Term("owner", "sue")), BooleanClause.Occur.SHOULD);
query = bq;
// date filter matches everything too
//Date pastTheEnd = parseDate("2099 Jan 1");
// dateFilter = DateFilter.Before("date", pastTheEnd);
// just treat dates as strings and select the whole range for now...
dateFilter = new TermRangeFilter("date", "", "ZZZZ", true, true);
bobFilter = new QueryWrapperFilter(
new TermQuery(new Term("owner", "bob")));
sueFilter = new QueryWrapperFilter(
new TermQuery(new Term("owner", "sue")));
}
public override void SetUp()
{
base.SetUp();
directory = NewDirectory();
RandomIndexWriter writer = new RandomIndexWriter(Random(), directory);
// we use the default Locale/TZ since LuceneTestCase randomizes it
var cal = new DateTime(1970, 1, 1, 0, 0, 0, (int)TestUtil.NextLong(Random(), 0, long.MaxValue), new GregorianCalendar());
for (int i = 0; i < Max; i++)
{
Document doc = new Document();
doc.Add(NewStringField("key", "" + (i + 1), Field.Store.YES));
doc.Add(NewStringField("owner", (i < Max / 2) ? "bob" : "sue", Field.Store.YES));
doc.Add(NewStringField("date", cal.ToString(CultureInfo.InvariantCulture), Field.Store.YES));
writer.AddDocument(doc);
cal = cal.AddDays(1);
}
reader = writer.Reader;
writer.Dispose();
searcher = NewSearcher(reader);
// query for everything to make life easier
BooleanQuery bq = new BooleanQuery();
bq.Add(new TermQuery(new Term("owner", "bob")), BooleanClause.Occur.SHOULD);
bq.Add(new TermQuery(new Term("owner", "sue")), BooleanClause.Occur.SHOULD);
query = bq;
// date filter matches everything too
//Date pastTheEnd = parseDate("2099 Jan 1");
// dateFilter = DateFilter.Before("date", pastTheEnd);
// just treat dates as strings and select the whole range for now...
dateFilter = TermRangeFilter.NewStringRange("date", "", "ZZZZ", true, true);
bobFilter = new QueryWrapperFilter(new TermQuery(new Term("owner", "bob")));
sueFilter = new QueryWrapperFilter(new TermQuery(new Term("owner", "sue")));
}
private SearchResults SearchCore(SearchFilter searchFilter)
{
// Get index timestamp
DateTime timestamp = File.GetLastWriteTimeUtc(LuceneCommon.IndexMetadataPath);
int numRecords = searchFilter.Skip + searchFilter.Take;
var searcher = new IndexSearcher(_directory, readOnly: true);
var query = ParseQuery(searchFilter);
// If searching by relevance, boost scores by download count.
if (searchFilter.SortProperty == SortProperty.Relevance)
{
var downloadCountBooster = new FieldScoreQuery("DownloadCount", FieldScoreQuery.Type.INT);
query = new CustomScoreQuery(query, downloadCountBooster);
}
var filterTerm = searchFilter.IncludePrerelease ? "IsLatest" : "IsLatestStable";
Query filterQuery = new TermQuery(new Term(filterTerm, Boolean.TrueString));
Filter filter = new QueryWrapperFilter(filterQuery);
var results = searcher.Search(query, filter: filter, n: numRecords, sort: new Sort(GetSortField(searchFilter)));
if (results.TotalHits == 0 || searchFilter.CountOnly)
{
return new SearchResults(results.TotalHits, timestamp);
}
var packages = results.ScoreDocs
.Skip(searchFilter.Skip)
.Select(sd => PackageFromDoc(searcher.Doc(sd.Doc)))
.ToList();
return new SearchResults(
results.TotalHits,
timestamp,
packages.AsQueryable());
}
public virtual void TestBasic()
{
Directory dir = new RAMDirectory();
IndexWriter writer = new IndexWriter(dir, new StandardAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
Document doc = new Document();
doc.Add(new Field("field", "value", Field.Store.NO, Field.Index.ANALYZED));
writer.AddDocument(doc);
writer.Close();
TermQuery termQuery = new TermQuery(new Term("field", "value"));
// should not throw exception with primitive query
QueryWrapperFilter qwf = new QueryWrapperFilter(termQuery);
IndexSearcher searcher = new IndexSearcher(dir, true);
TopDocs hits = searcher.Search(new MatchAllDocsQuery(), qwf, 10);
Assert.AreEqual(1, hits.totalHits);
// should not throw exception with complex primitive query
BooleanQuery booleanQuery = new BooleanQuery();
booleanQuery.Add(termQuery, Occur.MUST);
booleanQuery.Add(new TermQuery(new Term("field", "missing")), Occur.MUST_NOT);
qwf = new QueryWrapperFilter(termQuery);
hits = searcher.Search(new MatchAllDocsQuery(), qwf, 10);
Assert.AreEqual(1, hits.totalHits);
// should not throw exception with non primitive Query (doesn't implement
// Query#createWeight)
qwf = new QueryWrapperFilter(new FuzzyQuery(new Term("field", "valu")));
hits = searcher.Search(new MatchAllDocsQuery(), qwf, 10);
Assert.AreEqual(1, hits.totalHits);
}
/// <summary>
/// Processes the next tweet from the queue
/// </summary>
public void ProcessNextInQueue()
{
//read the tweets with a MinValue as their index date
TermQuery query = new TermQuery(new Term(Settings.FIELD_TWEET_DATE_INDEXED, "0"));
Filter filter = new QueryWrapperFilter(query);
TopDocs results = _tweetSearcher.Search(query, filter, 1);
//if no results, return
if (results.totalHits == 0)
return;
Document tweetDoc = _tweetSearcher.Doc(results.scoreDocs[0].doc);
//construct the tweet
Tweet tweetToProcess = GetTweetFromDocument(tweetDoc);
Console.WriteLine("Processing Tweet " + tweetToProcess.TweetId);
//get the indexes
var indexes = GetIndexesFromDocument(tweetDoc);
//index the urls from the tweet
_urlIndexer.IndexUrlsInTweet(tweetToProcess, indexes);
}
private void InitBlock(Lucene.Net.Search.Weight weight, Lucene.Net.Index.IndexReader reader, QueryWrapperFilter enclosingInstance)
{
this.weight = weight;
this.reader = reader;
this.enclosingInstance = enclosingInstance;
}
public SearchResults Search(SearchRequest request)
{
if (!OpenReader())
{
return new SearchResults { Query = request.Query };
}
if (!reader.IsCurrent())
{
reader = reader.Reopen();
}
var take = request.Take > 0 ? request.Take : SearchModuleConstants.DefaultSearchResultsCount;
var skip = request.Skip > 0 ? request.Skip : 0;
var result = new List<SearchResultItem>();
TopScoreDocCollector collector = TopScoreDocCollector.Create(take + skip, true);
using (var searcher = new IndexSearcher(reader))
{
var searchQuery = request.Query;
Query query;
try
{
query = parser.Parse(searchQuery);
}
catch (ParseException)
{
try
{
searchQuery = QueryParser.Escape(searchQuery);
query = parser.Parse(searchQuery);
}
catch (ParseException exc)
{
throw new ValidationException(() => exc.Message, exc.Message, exc);
}
}
Filter isPublishedFilter = null;
if (!RetrieveUnpublishedPages())
{
var isPublishedQuery = new TermQuery(new Term(LuceneIndexDocumentKeys.IsPublished, "true"));
isPublishedFilter = new QueryWrapperFilter(isPublishedQuery);
}
if (LuceneSearchHelper.Search != null)
{
collector = LuceneSearchHelper.Search(query, isPublishedFilter, collector);
}
else
{
query = LuceneEvents.Instance.OnSearchQueryExecuting(query, searchQuery).Query;
if (isPublishedFilter != null)
{
// Exclude unpublished pages
searcher.Search(query, isPublishedFilter, collector);
}
else
{
// Search within all the pages
searcher.Search(query, collector);
}
}
ScoreDoc[] hits = collector.TopDocs(skip, take).ScoreDocs;
List<Document> hitDocuments = new List<Document>();
for (int i = 0; i < hits.Length; i++)
{
int docId = hits[i].Doc;
Document d = searcher.Doc(docId);
hitDocuments.Add(d);
result.Add(
new SearchResultItem
{
FormattedUrl = d.Get(LuceneIndexDocumentKeys.Path),
Link = d.Get(LuceneIndexDocumentKeys.Path),
Title = d.Get(LuceneIndexDocumentKeys.Title),
Snippet = GetSnippet(d.Get(LuceneIndexDocumentKeys.Content), request.Query)
});
}
CheckAvailability(result);
LuceneEvents.Instance.OnSearchResultRetrieving(hitDocuments, result);
}
return new SearchResults
{
Items = result,
Query = request.Query,
TotalResults = collector.TotalHits
};
}
/// <summary>
/// performs a basic query
/// </summary>
private TopDocs PerformQuery(Query query)
{
Filter filter = new QueryWrapperFilter(query);
return _searcher.Search(query, filter, 10);
}
private void InitBlock(OpenBitSet bits, QueryWrapperFilter enclosingInstance)
{
this.bits = bits;
this.enclosingInstance = enclosingInstance;
}
public virtual void TestQueryWrapperFilter()
{
Directory d = NewDirectory();
RandomIndexWriter w = new RandomIndexWriter(Random(), d, Similarity, TimeZone);
Document doc = new Document();
doc.Add(NewStringField("field", "a", Field.Store.NO));
w.AddDocument(doc);
IndexReader r = w.Reader;
w.Dispose();
Filter filter = new QueryWrapperFilter(AssertingQuery.Wrap(Random(), new TermQuery(new Term("field", "a"))));
IndexSearcher s = NewSearcher(r);
Debug.Assert(s is AssertingIndexSearcher);
// this used to fail
s.Search(new ConstantScoreQuery(filter), new TotalHitCountCollector());
// check the rewrite
Query rewritten = (new ConstantScoreQuery(filter)).Rewrite(r);
Assert.IsTrue(rewritten is ConstantScoreQuery);
Assert.IsTrue(((ConstantScoreQuery)rewritten).Query is AssertingQuery);
r.Dispose();
d.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 AnonymousClassHitCollector(System.Collections.BitArray bits, QueryWrapperFilter enclosingInstance)
{
InitBlock(bits, enclosingInstance);
}
public static List<IndexItem> GetRecentModifiedContent(
int siteId,
Guid[] featureGuids,
DateTime modifiedSinceDate,
int maxItems)
{
int totalHits = 0;
List<IndexItem> results = new List<IndexItem>();
using (Lucene.Net.Store.Directory searchDirectory = GetDirectory(siteId))
{
Filter filter = null;
BooleanQuery filterQuery = new BooleanQuery(); // won't be used to score the results
BooleanQuery excludeFilter = new BooleanQuery();
excludeFilter.Add(new TermQuery(new Term("ExcludeFromRecentContent", "false")), Occur.MUST);
filterQuery.Add(excludeFilter, Occur.MUST);
TermRangeQuery lastModifiedDateFilter = new TermRangeQuery(
"LastModUtc",
modifiedSinceDate.Date.ToString("s"),
DateTime.MaxValue.ToString("s"),
true,
true);
filterQuery.Add(lastModifiedDateFilter, Occur.MUST);
// we only want public content, that is both page and module roles must have "All Users"
// which means even unauthenticated users
Term pageRole = new Term("Role", "All Users");
TermQuery pageRoleFilter = new TermQuery(pageRole);
filterQuery.Add(pageRoleFilter, Occur.MUST);
Term moduleRole = new Term("ModuleRole", "All Users");
TermQuery moduleRoleFilter = new TermQuery(moduleRole);
filterQuery.Add(moduleRoleFilter, Occur.MUST);
if ((featureGuids != null)&&(featureGuids.Length > 0))
{
BooleanQuery featureFilter = new BooleanQuery();
foreach (Guid featureGuid in featureGuids)
{
featureFilter.Add(new TermQuery(new Term("FeatureId", featureGuid.ToString())), Occur.SHOULD);
}
filterQuery.Add(featureFilter, Occur.MUST);
}
filter = new QueryWrapperFilter(filterQuery); // filterQuery won't affect result scores
MatchAllDocsQuery matchAllQuery = new MatchAllDocsQuery();
using (IndexSearcher searcher = new IndexSearcher(searchDirectory))
{
int maxResults = int.MaxValue;
TopDocs hits = searcher.Search(matchAllQuery, filter, maxResults);
totalHits = hits.TotalHits;
for (int i = 0; i < totalHits; i++)
{
Document doc = searcher.Doc(hits.ScoreDocs[i].Doc);
IndexItem indexItem = new IndexItem(doc, hits.ScoreDocs[i].Score);
results.Add(indexItem);
}
}
}
// sort all descending on lastmodutc
results.Sort();
if (results.Count <= maxItems)
{
return results;
}
else
{
List<IndexItem> finalResults = new List<IndexItem>();
for (int i = 0; i < maxItems; i++)
{
finalResults.Add(results[i]);
}
return finalResults;
}
}
public static IndexItemCollection Browse(
int siteId,
Guid featureGuid,
DateTime modifiedBeginDate,
DateTime modifiedEndDate,
int pageNumber,
int pageSize,
out int totalHits)
{
totalHits = 0;
IndexItemCollection results = new IndexItemCollection();
using (Lucene.Net.Store.Directory searchDirectory = GetDirectory(siteId))
{
Filter filter = null;
BooleanQuery filterQuery = null;
if ((modifiedBeginDate.Date > DateTime.MinValue.Date) || (modifiedEndDate.Date < DateTime.MaxValue.Date))
{
filterQuery = new BooleanQuery(); // won't be used to score the results
TermRangeQuery lastModifiedDateFilter = new TermRangeQuery(
"LastModUtc",
modifiedBeginDate.Date.ToString("s"),
modifiedEndDate.Date.ToString("s"),
true,
true);
filterQuery.Add(lastModifiedDateFilter, Occur.MUST);
}
if (featureGuid != Guid.Empty)
{
if (filterQuery == null) { filterQuery = new BooleanQuery(); }
BooleanQuery featureFilter = new BooleanQuery();
featureFilter.Add(new TermQuery(new Term("FeatureId", featureGuid.ToString())), Occur.MUST);
filterQuery.Add(featureFilter, Occur.MUST);
}
if (filterQuery != null)
{
filter = new QueryWrapperFilter(filterQuery); // filterQuery won't affect result scores
}
MatchAllDocsQuery matchAllQuery = new MatchAllDocsQuery();
using (IndexSearcher searcher = new IndexSearcher(searchDirectory))
{
int maxResults = int.MaxValue;
TopDocs hits = searcher.Search(matchAllQuery, filter, maxResults);
int startHit = 0;
if (pageNumber > 1)
{
startHit = ((pageNumber - 1) * pageSize);
}
totalHits = hits.TotalHits;
if (startHit > totalHits)
{
startHit = totalHits;
}
int end = startHit + pageSize;
if (totalHits <= end)
{
end = totalHits;
}
int itemsAdded = 0;
int itemsToAdd = end;
for (int i = startHit; i < itemsToAdd; i++)
{
Document doc = searcher.Doc(hits.ScoreDocs[i].Doc);
IndexItem indexItem = new IndexItem(doc, hits.ScoreDocs[i].Score);
results.Add(indexItem);
itemsAdded += 1;
}
results.ItemCount = itemsAdded;
results.PageIndex = pageNumber;
results.ExecutionTime = DateTime.Now.Ticks; // -0;
}
// using (IndexReader reader = IndexReader.Open(searchDirectory, false))
// {
// totalHits = reader.NumDocs();
// int startHit = 0;
// int itemsToAdd = pageSize;
// if (pageNumber > 1)
// {
// startHit = ((pageNumber - 1) * pageSize);
// int end = startHit + pageSize;
// if (totalHits <= end)
// {
// end = totalHits;
// }
// itemsToAdd = end;
// }
// for (int i = startHit; i < itemsToAdd; i++)
// {
// Document doc = reader.Document(i);
// IndexItem indexItem = new IndexItem(doc, 1);
// results.Add(indexItem);
// }
// }
}
return results;
}
/// <summary>
/// 构建Query、Filter、Sort
/// </summary>
/// <param name="query"><see cref="Query"/></param>
/// <param name="filter"><see cref="Filter"/></param>
/// <param name="sort"><see cref="Sort"/></param>
public void BuildQuery(out Query query, out Filter filter, out Sort sort)
{
BooleanQuery q = new BooleanQuery();
foreach (var clause in clauses)
{
q.Add(clause);
}
query = q;
if (filters.Count > 0)
{
BooleanQuery filterQuery = new BooleanQuery();
foreach (var _filter in filters)
filterQuery.Add(_filter);
filter = new QueryWrapperFilter(filterQuery);
}
else
{
filter = null;
}
if (sortFields.Count > 0)
sort = new Sort(sortFields.ToArray());
else
sort = null;
}
protected OpenBitSetDISI CalculateOpenBitSetDisi(string facetAttributeFieldName, string value)
{
var facetQuery = new TermQuery(new Term(facetAttributeFieldName, value));
var facetQueryFilter = new QueryWrapperFilter(facetQuery);
return new OpenBitSetDISI(facetQueryFilter.GetDocIdSet(IndexReader).Iterator(), IndexReader.MaxDoc);
}
private Query CreateQuery()
{
CreatePendingClause();
var booleanQuery = new BooleanQuery();
Query resultQuery = booleanQuery;
if (_clauses.Count == 0) {
if (_filters.Count > 0) { // only filters applieds => transform to a boolean query
foreach (var clause in _filters) {
booleanQuery.Add(clause);
}
resultQuery = booleanQuery;
}
else { // search all documents, without filter or clause
resultQuery = new MatchAllDocsQuery(null);
}
}
else {
foreach (var clause in _clauses)
booleanQuery.Add(clause);
if (_filters.Count > 0) {
var filter = new BooleanQuery();
foreach (var clause in _filters)
filter.Add(clause);
var queryFilter = new QueryWrapperFilter(filter);
resultQuery = new FilteredQuery(booleanQuery, queryFilter);
}
}
Logger.Debug("New search query: {0}", resultQuery.ToString());
return resultQuery;
}
public ISearchBits GetBits()
{
var query = CreateQuery();
IndexSearcher searcher;
try {
searcher = new IndexSearcher(_directory, true);
}
catch {
// index might not exist if it has been rebuilt
Logger.Information("Attempt to read a none existing index");
return null;
}
try {
var filter = new QueryWrapperFilter(query);
var bits = filter.GetDocIdSet(searcher.GetIndexReader());
var disi = new OpenBitSetDISI(bits.Iterator(), searcher.MaxDoc());
return new SearchBits(disi);
}
finally {
searcher.Close();
}
}
public static TopDocs Search(this Searcher searcher, string type, Query Filter, Query query, int numResults)
{
Filter filter = new QueryWrapperFilter(query);
return(searcher.Search(query, JsonMappingUtils.GetTypeFilter(type, Filter), numResults));
}
public AnonymousClassDocIdSet(Lucene.Net.Search.Weight weight, Lucene.Net.Index.IndexReader reader, QueryWrapperFilter enclosingInstance)
{
InitBlock(weight, reader, enclosingInstance);
}
public static IndexItemCollection Search(
int siteId,
bool isAdminContentAdminOrSiteEditor,
List<string> userRoles,
Guid[] featureGuids,
DateTime modifiedBeginDate,
DateTime modifiedEndDate,
string queryText,
bool highlightResults,
int highlightedFragmentSize,
int pageNumber,
int pageSize,
int maxClauseCount,
out int totalHits,
out bool invalidQuery)
{
invalidQuery = false;
totalHits = 0;
IndexItemCollection results = new IndexItemCollection();
if (string.IsNullOrEmpty(queryText))
{
return results;
}
using (Lucene.Net.Store.Directory searchDirectory = GetDirectory(siteId))
{
if (!IndexReader.IndexExists(searchDirectory)) { return results; }
long startTicks = DateTime.Now.Ticks;
try
{
if (maxClauseCount != 1024)
{
BooleanQuery.MaxClauseCount = maxClauseCount;
}
// there are different analyzers for different languages
// see LuceneSettings.config in the root of the web
LuceneSettingsProvider provider = LuceneSettingsManager.Providers[GetSiteProviderName(siteId)];
Analyzer analyzer = provider.GetAnalyzer();
Query searchQuery = MultiFieldQueryParser.Parse(
Lucene.Net.Util.Version.LUCENE_30,
new string[] { queryText, queryText, queryText, queryText, queryText, queryText.Replace("*", string.Empty) },
new string[] { "Title", "ModuleTitle", "contents", "PageName", "PageMetaDesc", "Keyword" },
analyzer);
BooleanQuery filterQuery = new BooleanQuery(); // won't be used to score the results
if (!isAdminContentAdminOrSiteEditor) // skip role filters for these users
{
AddRoleFilters(userRoles, filterQuery);
AddModuleRoleFilters(userRoles, filterQuery);
}
TermRangeQuery beginDateFilter = new TermRangeQuery(
"PublishBeginDate",
DateTime.MinValue.ToString("s"),
DateTime.UtcNow.ToString("s"),
true,
true);
filterQuery.Add(beginDateFilter, Occur.MUST);
TermRangeQuery endDateFilter = new TermRangeQuery(
"PublishEndDate",
DateTime.UtcNow.ToString("s"),
DateTime.MaxValue.ToString("s"),
true,
true);
filterQuery.Add(endDateFilter, Occur.MUST);
if ((modifiedBeginDate.Date > DateTime.MinValue.Date) || (modifiedEndDate.Date < DateTime.MaxValue.Date))
{
TermRangeQuery lastModifiedDateFilter = new TermRangeQuery(
"LastModUtc",
modifiedBeginDate.Date.ToString("s"),
modifiedEndDate.Date.ToString("s"),
true,
true);
filterQuery.Add(lastModifiedDateFilter, Occur.MUST);
}
//if ((!DisableSearchFeatureFilters) && (featureGuid != Guid.Empty))
//{
// BooleanQuery featureFilter = new BooleanQuery();
// featureFilter.Add(new TermQuery(new Term("FeatureId", featureGuid.ToString())), Occur.MUST);
// filterQuery.Add(featureFilter, Occur.MUST);
//}
if ((featureGuids != null) && (featureGuids.Length > 0))
{
BooleanQuery featureFilter = new BooleanQuery();
foreach (Guid featureGuid in featureGuids)
{
featureFilter.Add(new TermQuery(new Term("FeatureId", featureGuid.ToString())), Occur.SHOULD);
}
filterQuery.Add(featureFilter, Occur.MUST);
}
Filter filter = new QueryWrapperFilter(filterQuery); // filterQuery won't affect result scores
using (IndexSearcher searcher = new IndexSearcher(searchDirectory))
{
//http://stackoverflow.com/questions/9872933/migrating-lucene-hitcollector-2-x-to-collector-3-x
//TopScoreDocCollector collector = TopScoreDocCollector.Create(maxResults, true);
int maxResults = int.MaxValue;
TopDocs hits = searcher.Search(searchQuery, filter, maxResults);
int startHit = 0;
if (pageNumber > 1)
{
startHit = ((pageNumber - 1) * pageSize);
}
totalHits = hits.TotalHits;
int end = startHit + pageSize;
if (totalHits <= end)
{
end = totalHits;
}
int itemsAdded = 0;
int itemsToAdd = end;
QueryScorer scorer = new QueryScorer(searchQuery);
SimpleHTMLFormatter formatter = new SimpleHTMLFormatter("<span class='searchterm'>", "</span>");
Highlighter highlighter = new Highlighter(formatter, scorer);
highlighter.TextFragmenter = new SimpleFragmenter(highlightedFragmentSize);
for (int i = startHit; i < itemsToAdd; i++)
{
Document doc = searcher.Doc(hits.ScoreDocs[i].Doc);
IndexItem indexItem = new IndexItem(doc, hits.ScoreDocs[i].Score);
if (highlightResults)
{
try
{
TokenStream stream = analyzer.TokenStream("contents", new StringReader(doc.Get("contents")));
string highlightedResult = highlighter.GetBestFragment(stream, doc.Get("contents"));
if (highlightedResult != null) { indexItem.Intro = highlightedResult; }
}
catch (NullReferenceException) { }
}
results.Add(indexItem);
itemsAdded += 1;
}
results.ItemCount = itemsAdded;
results.PageIndex = pageNumber;
results.ExecutionTime = DateTime.Now.Ticks - startTicks;
}
}
catch (ParseException ex)
{
invalidQuery = true;
log.Error("handled error for search terms " + queryText, ex);
// these parser exceptions are generally caused by
// spambots posting too much junk into the search form
// heres an option to automatically ban the ip address
HandleSpam(queryText, ex);
return results;
}
catch (BooleanQuery.TooManyClauses ex)
{
invalidQuery = true;
log.Error("handled error for search terms " + queryText, ex);
return results;
}
catch (System.IO.IOException ex)
{
invalidQuery = true;
log.Error("handled error for search terms " + queryText, ex);
return results;
}
return results;
}
}
private void InitBlock(System.Collections.BitArray bits, QueryWrapperFilter enclosingInstance)
{
this.bits = bits;
this.enclosingInstance = enclosingInstance;
}
public AnonymousClassDocIdSet(Lucene.Net.Search.Weight weight, Lucene.Net.Index.IndexReader reader, QueryWrapperFilter enclosingInstance)
{
InitBlock(weight, reader, enclosingInstance);
}
private void InitBlock(System.Collections.BitArray bits, QueryWrapperFilter enclosingInstance)
{
this.bits = bits;
this.enclosingInstance = enclosingInstance;
}
private void InitBlock(Lucene.Net.Search.Weight weight, Lucene.Net.Index.IndexReader reader, QueryWrapperFilter enclosingInstance)
{
this.weight = weight;
this.reader = reader;
this.enclosingInstance = enclosingInstance;
}
public void TestEnforceDeletions()
{
Directory dir = new MockRAMDirectory();
IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), IndexWriter.MaxFieldLength.UNLIMITED);
IndexReader reader = writer.GetReader();
IndexSearcher searcher = new IndexSearcher(reader);
// add a doc, refresh the reader, and check that its there
Document doc = new Document();
doc.Add(new Field("id", "1", Field.Store.YES, Field.Index.NOT_ANALYZED));
writer.AddDocument(doc);
reader = RefreshReader(reader);
searcher = new IndexSearcher(reader);
TopDocs docs = searcher.Search(new MatchAllDocsQuery(), 1);
Assert.AreEqual(1, docs.TotalHits, "Should find a hit...");
Filter startFilter = new QueryWrapperFilter(new TermQuery(new Term("id", "1")));
// ignore deletions
CachingWrapperFilter filter = new CachingWrapperFilter(startFilter, CachingWrapperFilter.DeletesMode.IGNORE);
docs = searcher.Search(new MatchAllDocsQuery(), filter, 1);
Assert.AreEqual(1, docs.TotalHits, "[query + filter] Should find a hit...");
ConstantScoreQuery constantScore = new ConstantScoreQuery(filter);
docs = searcher.Search(constantScore, 1);
Assert.AreEqual(1, docs.TotalHits, "[just filter] Should find a hit...");
// now delete the doc, refresh the reader, and see that it's not there
writer.DeleteDocuments(new Term("id", "1"));
reader = RefreshReader(reader);
searcher = new IndexSearcher(reader);
docs = searcher.Search(new MatchAllDocsQuery(), filter, 1);
Assert.AreEqual(0, docs.TotalHits, "[query + filter] Should *not* find a hit...");
docs = searcher.Search(constantScore, 1);
Assert.AreEqual(1, docs.TotalHits, "[just filter] Should find a hit...");
// force cache to regenerate:
filter = new CachingWrapperFilter(startFilter, CachingWrapperFilter.DeletesMode.RECACHE);
writer.AddDocument(doc);
reader = RefreshReader(reader);
searcher = new IndexSearcher(reader);
docs = searcher.Search(new MatchAllDocsQuery(), filter, 1);
Assert.AreEqual(1, docs.TotalHits, "[query + filter] Should find a hit...");
constantScore = new ConstantScoreQuery(filter);
docs = searcher.Search(constantScore, 1);
Assert.AreEqual(1, docs.TotalHits, "[just filter] Should find a hit...");
// make sure we get a cache hit when we reopen reader
// that had no change to deletions
IndexReader newReader = RefreshReader(reader);
Assert.IsTrue(reader != newReader);
reader = newReader;
searcher = new IndexSearcher(reader);
int missCount = filter.missCount;
docs = searcher.Search(constantScore, 1);
Assert.AreEqual(1, docs.TotalHits, "[just filter] Should find a hit...");
Assert.AreEqual(missCount, filter.missCount);
// now delete the doc, refresh the reader, and see that it's not there
writer.DeleteDocuments(new Term("id", "1"));
reader = RefreshReader(reader);
searcher = new IndexSearcher(reader);
missCount = filter.missCount;
docs = searcher.Search(new MatchAllDocsQuery(), filter, 1);
Assert.AreEqual(missCount + 1, filter.missCount);
Assert.AreEqual(0, docs.TotalHits, "[query + filter] Should *not* find a hit...");
docs = searcher.Search(constantScore, 1);
Assert.AreEqual(0, docs.TotalHits, "[just filter] Should *not* find a hit...");
// apply deletions dynamically
filter = new CachingWrapperFilter(startFilter, CachingWrapperFilter.DeletesMode.DYNAMIC);
writer.AddDocument(doc);
reader = RefreshReader(reader);
searcher = new IndexSearcher(reader);
docs = searcher.Search(new MatchAllDocsQuery(), filter, 1);
Assert.AreEqual(1, docs.TotalHits, "[query + filter] Should find a hit...");
constantScore = new ConstantScoreQuery(filter);
docs = searcher.Search(constantScore, 1);
Assert.AreEqual(1, docs.TotalHits, "[just filter] Should find a hit...");
// now delete the doc, refresh the reader, and see that it's not there
writer.DeleteDocuments(new Term("id", "1"));
reader = RefreshReader(reader);
searcher = new IndexSearcher(reader);
docs = searcher.Search(new MatchAllDocsQuery(), filter, 1);
Assert.AreEqual(0, docs.TotalHits, "[query + filter] Should *not* find a hit...");
missCount = filter.missCount;
docs = searcher.Search(constantScore, 1);
Assert.AreEqual(0, docs.TotalHits, "[just filter] Should *not* find a hit...");
// doesn't count as a miss
Assert.AreEqual(missCount, filter.missCount);
}
public virtual void TestWithCachingFilter()
{
Directory dir = NewDirectory();
RandomIndexWriter writer = new RandomIndexWriter(Random(), dir);
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 TestRandom()
{
// We build two indices at once: one normalized (which
// ToParentBlockJoinQuery/Collector,
// ToChildBlockJoinQuery can query) and the other w/
// the same docs, just fully denormalized:
Directory dir = NewDirectory();
Directory joinDir = NewDirectory();
int numParentDocs = TestUtil.NextInt(Random(), 100 * RANDOM_MULTIPLIER, 300 * RANDOM_MULTIPLIER);
//final int numParentDocs = 30;
// Values for parent fields:
string[][] parentFields = GetRandomFields(numParentDocs / 2);
// Values for child fields:
string[][] childFields = GetRandomFields(numParentDocs);
bool doDeletes = Random().NextBoolean();
IList<int> toDelete = new List<int>();
// TODO: parallel star join, nested join cases too!
RandomIndexWriter w = new RandomIndexWriter(Random(), dir, Similarity, TimeZone);
RandomIndexWriter joinW = new RandomIndexWriter(Random(), joinDir, Similarity, TimeZone);
for (int parentDocID = 0; parentDocID < numParentDocs; parentDocID++)
{
Document parentDoc = new Document();
Document parentJoinDoc = new Document();
Field id = NewStringField("parentID", "" + parentDocID, Field.Store.YES);
parentDoc.Add(id);
parentJoinDoc.Add(id);
parentJoinDoc.Add(NewStringField("isParent", "x", Field.Store.NO));
for (int field = 0; field < parentFields.Length; field++)
{
if (Random().NextDouble() < 0.9)
{
Field f = NewStringField("parent" + field, parentFields[field][Random().Next(parentFields[field].Length)], Field.Store.NO);
parentDoc.Add(f);
parentJoinDoc.Add(f);
}
}
if (doDeletes)
{
parentDoc.Add(NewStringField("blockID", "" + parentDocID, Field.Store.NO));
parentJoinDoc.Add(NewStringField("blockID", "" + parentDocID, Field.Store.NO));
}
IList<Document> joinDocs = new List<Document>();
if (VERBOSE)
{
StringBuilder sb = new StringBuilder();
sb.Append("parentID=").Append(parentDoc.Get("parentID"));
for (int fieldID = 0; fieldID < parentFields.Length; fieldID++)
{
string parent = parentDoc.Get("parent" + fieldID);
if (parent != null)
{
sb.Append(" parent" + fieldID + "=" + parent);
}
}
Console.WriteLine(" " + sb);
}
int numChildDocs = TestUtil.NextInt(Random(), 1, 20);
for (int childDocID = 0; childDocID < numChildDocs; childDocID++)
{
// Denormalize: copy all parent fields into child doc:
Document childDoc = TestUtil.CloneDocument(parentDoc);
Document joinChildDoc = new Document();
joinDocs.Add(joinChildDoc);
Field childID = NewStringField("childID", "" + childDocID, Field.Store.YES);
childDoc.Add(childID);
joinChildDoc.Add(childID);
for (int childFieldID = 0; childFieldID < childFields.Length; childFieldID++)
{
if (Random().NextDouble() < 0.9)
{
Field f = NewStringField("child" + childFieldID, childFields[childFieldID][Random().Next(childFields[childFieldID].Length)], Field.Store.NO);
childDoc.Add(f);
joinChildDoc.Add(f);
}
}
if (VERBOSE)
{
StringBuilder sb = new StringBuilder();
sb.Append("childID=").Append(joinChildDoc.Get("childID"));
for (int fieldID = 0; fieldID < childFields.Length; fieldID++)
{
string child = joinChildDoc.Get("child" + fieldID);
if (child != null)
{
sb.Append(" child" + fieldID + "=" + child);
}
}
Console.WriteLine(" " + sb);
}
if (doDeletes)
{
joinChildDoc.Add(NewStringField("blockID", "" + parentDocID, Field.Store.NO));
}
w.AddDocument(childDoc);
}
// Parent last:
joinDocs.Add(parentJoinDoc);
joinW.AddDocuments(joinDocs);
if (doDeletes && Random().Next(30) == 7)
{
toDelete.Add(parentDocID);
}
}
foreach (int deleteID in toDelete)
{
if (VERBOSE)
{
Console.WriteLine("DELETE parentID=" + deleteID);
}
w.DeleteDocuments(new Term("blockID", "" + deleteID));
joinW.DeleteDocuments(new Term("blockID", "" + deleteID));
}
IndexReader r = w.Reader;
w.Dispose();
IndexReader joinR = joinW.Reader;
joinW.Dispose();
if (VERBOSE)
{
Console.WriteLine("TEST: reader=" + r);
Console.WriteLine("TEST: joinReader=" + joinR);
for (int docIDX = 0; docIDX < joinR.MaxDoc; docIDX++)
{
Console.WriteLine(" docID=" + docIDX + " doc=" + joinR.Document(docIDX));
}
}
IndexSearcher s = NewSearcher(r);
IndexSearcher joinS = new IndexSearcher(joinR);
Filter parentsFilter = new FixedBitSetCachingWrapperFilter(new QueryWrapperFilter(new TermQuery(new Term("isParent", "x"))));
int iters = 200 * RANDOM_MULTIPLIER;
for (int iter = 0; iter < iters; iter++)
{
if (VERBOSE)
{
Console.WriteLine("TEST: iter=" + (1 + iter) + " of " + iters);
}
Query childQuery;
if (Random().Next(3) == 2)
{
int childFieldID = Random().Next(childFields.Length);
childQuery = new TermQuery(new Term("child" + childFieldID, childFields[childFieldID][Random().Next(childFields[childFieldID].Length)]));
}
else if (Random().Next(3) == 2)
{
BooleanQuery bq = new BooleanQuery();
childQuery = bq;
int numClauses = TestUtil.NextInt(Random(), 2, 4);
bool didMust = false;
for (int clauseIDX = 0; clauseIDX < numClauses; clauseIDX++)
{
Query clause;
BooleanClause.Occur occur;
if (!didMust && Random().NextBoolean())
{
occur = Random().NextBoolean() ? BooleanClause.Occur.MUST : BooleanClause.Occur.MUST_NOT;
clause = new TermQuery(RandomChildTerm(childFields[0]));
didMust = true;
}
else
{
occur = BooleanClause.Occur.SHOULD;
int childFieldID = TestUtil.NextInt(Random(), 1, childFields.Length - 1);
clause = new TermQuery(new Term("child" + childFieldID, childFields[childFieldID][Random().Next(childFields[childFieldID].Length)]));
}
bq.Add(clause, occur);
}
}
else
{
BooleanQuery bq = new BooleanQuery();
childQuery = bq;
bq.Add(new TermQuery(RandomChildTerm(childFields[0])), BooleanClause.Occur.MUST);
int childFieldID = TestUtil.NextInt(Random(), 1, childFields.Length - 1);
bq.Add(new TermQuery(new Term("child" + childFieldID, childFields[childFieldID][Random().Next(childFields[childFieldID].Length)])), Random().NextBoolean() ? BooleanClause.Occur.MUST : BooleanClause.Occur.MUST_NOT);
}
int x = Random().Next(4);
ScoreMode agg;
if (x == 0)
{
agg = ScoreMode.None;
}
else if (x == 1)
{
agg = ScoreMode.Max;
}
else if (x == 2)
{
agg = ScoreMode.Total;
}
else
{
agg = ScoreMode.Avg;
}
ToParentBlockJoinQuery childJoinQuery = new ToParentBlockJoinQuery(childQuery, parentsFilter, agg);
// To run against the block-join index:
Query parentJoinQuery;
// Same query as parentJoinQuery, but to run against
// the fully denormalized index (so we can compare
// results):
Query parentQuery;
if (Random().NextBoolean())
{
parentQuery = childQuery;
parentJoinQuery = childJoinQuery;
}
else
{
// AND parent field w/ child field
BooleanQuery bq = new BooleanQuery();
parentJoinQuery = bq;
Term parentTerm = RandomParentTerm(parentFields[0]);
if (Random().NextBoolean())
{
bq.Add(childJoinQuery, BooleanClause.Occur.MUST);
bq.Add(new TermQuery(parentTerm), BooleanClause.Occur.MUST);
}
else
{
bq.Add(new TermQuery(parentTerm), BooleanClause.Occur.MUST);
bq.Add(childJoinQuery, BooleanClause.Occur.MUST);
}
BooleanQuery bq2 = new BooleanQuery();
parentQuery = bq2;
if (Random().NextBoolean())
{
bq2.Add(childQuery, BooleanClause.Occur.MUST);
bq2.Add(new TermQuery(parentTerm), BooleanClause.Occur.MUST);
}
else
{
bq2.Add(new TermQuery(parentTerm), BooleanClause.Occur.MUST);
bq2.Add(childQuery, BooleanClause.Occur.MUST);
}
}
Sort parentSort = GetRandomSort("parent", parentFields.Length);
Sort childSort = GetRandomSort("child", childFields.Length);
if (VERBOSE)
{
Console.WriteLine("\nTEST: query=" + parentQuery + " joinQuery=" + parentJoinQuery + " parentSort=" + parentSort + " childSort=" + childSort);
}
// Merge both sorts:
IList<SortField> sortFields = new List<SortField>(Arrays.AsList(parentSort.GetSort()));
sortFields.AddRange(Arrays.AsList(childSort.GetSort()));
Sort parentAndChildSort = new Sort(sortFields.ToArray());
TopDocs results = s.Search(parentQuery, null, r.NumDocs, parentAndChildSort);
if (VERBOSE)
{
Console.WriteLine("\nTEST: normal index gets " + results.TotalHits + " hits");
ScoreDoc[] hits = results.ScoreDocs;
for (int hitIDX = 0; hitIDX < hits.Length; hitIDX++)
{
Document doc = s.Doc(hits[hitIDX].Doc);
//System.out.println(" score=" + hits[hitIDX].Score + " parentID=" + doc.Get("parentID") + " childID=" + doc.Get("childID") + " (docID=" + hits[hitIDX].Doc + ")");
Console.WriteLine(" parentID=" + doc.Get("parentID") + " childID=" + doc.Get("childID") + " (docID=" + hits[hitIDX].Doc + ")");
FieldDoc fd = (FieldDoc)hits[hitIDX];
if (fd.Fields != null)
{
Console.Write(" ");
foreach (object o in fd.Fields)
{
if (o is BytesRef)
{
Console.Write(((BytesRef)o).Utf8ToString() + " ");
}
else
{
Console.Write(o + " ");
}
}
Console.WriteLine();
}
}
}
bool trackScores;
bool trackMaxScore;
if (agg == ScoreMode.None)
{
trackScores = false;
trackMaxScore = false;
}
else
{
trackScores = Random().NextBoolean();
trackMaxScore = Random().NextBoolean();
}
ToParentBlockJoinCollector c = new ToParentBlockJoinCollector(parentSort, 10, trackScores, trackMaxScore);
joinS.Search(parentJoinQuery, c);
int hitsPerGroup = TestUtil.NextInt(Random(), 1, 20);
//final int hitsPerGroup = 100;
TopGroups<int> joinResults = c.GetTopGroups(childJoinQuery, childSort, 0, hitsPerGroup, 0, true);
if (VERBOSE)
{
Console.WriteLine("\nTEST: block join index gets " + (joinResults == null ? 0 : joinResults.Groups.Length) + " groups; hitsPerGroup=" + hitsPerGroup);
if (joinResults != null)
{
IGroupDocs<int>[] groups = joinResults.Groups;
for (int groupIDX = 0; groupIDX < groups.Length; groupIDX++)
{
IGroupDocs<int> group = groups[groupIDX];
if (group.GroupSortValues != null)
{
Console.Write(" ");
foreach (object o in group.GroupSortValues)
{
if (o is BytesRef)
{
Console.Write(((BytesRef)o).Utf8ToString() + " ");
}
else
{
Console.Write(o + " ");
}
}
Console.WriteLine();
}
assertNotNull(group.GroupValue);
Document parentDoc = joinS.Doc(group.GroupValue);
Console.WriteLine(" group parentID=" + parentDoc.Get("parentID") + " (docID=" + group.GroupValue + ")");
for (int hitIDX = 0; hitIDX < group.ScoreDocs.Length; hitIDX++)
{
Document doc = joinS.Doc(group.ScoreDocs[hitIDX].Doc);
//System.out.println(" score=" + group.ScoreDocs[hitIDX].Score + " childID=" + doc.Get("childID") + " (docID=" + group.ScoreDocs[hitIDX].Doc + ")");
Console.WriteLine(" childID=" + doc.Get("childID") + " child0=" + doc.Get("child0") + " (docID=" + group.ScoreDocs[hitIDX].Doc + ")");
}
}
}
}
if (results.TotalHits == 0)
{
assertNull(joinResults);
}
else
{
CompareHits(r, joinR, results, joinResults);
TopDocs b = joinS.Search(childJoinQuery, 10);
foreach (ScoreDoc hit in b.ScoreDocs)
{
Explanation explanation = joinS.Explain(childJoinQuery, hit.Doc);
Document document = joinS.Doc(hit.Doc - 1);
int childId = Convert.ToInt32(document.Get("childID"));
assertTrue(explanation.IsMatch);
assertEquals(hit.Score, explanation.Value, 0.0f);
assertEquals(string.Format("Score based on child doc range from {0} to {1}", hit.Doc - 1 - childId, hit.Doc - 1), explanation.Description);
}
}
// Test joining in the opposite direction (parent to
// child):
// Get random query against parent documents:
Query parentQuery2;
if (Random().Next(3) == 2)
{
int fieldID = Random().Next(parentFields.Length);
parentQuery2 = new TermQuery(new Term("parent" + fieldID, parentFields[fieldID][Random().Next(parentFields[fieldID].Length)]));
}
else if (Random().Next(3) == 2)
{
BooleanQuery bq = new BooleanQuery();
parentQuery2 = bq;
int numClauses = TestUtil.NextInt(Random(), 2, 4);
bool didMust = false;
for (int clauseIDX = 0; clauseIDX < numClauses; clauseIDX++)
{
Query clause;
BooleanClause.Occur occur;
if (!didMust && Random().NextBoolean())
{
occur = Random().NextBoolean() ? BooleanClause.Occur.MUST : BooleanClause.Occur.MUST_NOT;
clause = new TermQuery(RandomParentTerm(parentFields[0]));
didMust = true;
}
else
{
occur = BooleanClause.Occur.SHOULD;
int fieldID = TestUtil.NextInt(Random(), 1, parentFields.Length - 1);
clause = new TermQuery(new Term("parent" + fieldID, parentFields[fieldID][Random().Next(parentFields[fieldID].Length)]));
}
bq.Add(clause, occur);
}
}
else
{
BooleanQuery bq = new BooleanQuery();
parentQuery2 = bq;
bq.Add(new TermQuery(RandomParentTerm(parentFields[0])), BooleanClause.Occur.MUST);
int fieldID = TestUtil.NextInt(Random(), 1, parentFields.Length - 1);
bq.Add(new TermQuery(new Term("parent" + fieldID, parentFields[fieldID][Random().Next(parentFields[fieldID].Length)])), Random().NextBoolean() ? BooleanClause.Occur.MUST : BooleanClause.Occur.MUST_NOT);
}
if (VERBOSE)
{
Console.WriteLine("\nTEST: top down: parentQuery2=" + parentQuery2);
}
// Maps parent query to child docs:
ToChildBlockJoinQuery parentJoinQuery2 = new ToChildBlockJoinQuery(parentQuery2, parentsFilter, Random().NextBoolean());
// To run against the block-join index:
Query childJoinQuery2;
// Same query as parentJoinQuery, but to run against
// the fully denormalized index (so we can compare
// results):
Query childQuery2;
// apply a filter to children
Filter childFilter2, childJoinFilter2;
if (Random().NextBoolean())
{
childQuery2 = parentQuery2;
childJoinQuery2 = parentJoinQuery2;
childFilter2 = null;
childJoinFilter2 = null;
}
else
{
Term childTerm = RandomChildTerm(childFields[0]);
if (Random().NextBoolean()) // filtered case
{
childJoinQuery2 = parentJoinQuery2;
Filter f = new QueryWrapperFilter(new TermQuery(childTerm));
childJoinFilter2 = Random().NextBoolean() ? new FixedBitSetCachingWrapperFilter(f) : f;
}
else
{
childJoinFilter2 = null;
// AND child field w/ parent query:
BooleanQuery bq = new BooleanQuery();
childJoinQuery2 = bq;
if (Random().NextBoolean())
{
bq.Add(parentJoinQuery2, BooleanClause.Occur.MUST);
bq.Add(new TermQuery(childTerm), BooleanClause.Occur.MUST);
}
else
{
bq.Add(new TermQuery(childTerm), BooleanClause.Occur.MUST);
bq.Add(parentJoinQuery2, BooleanClause.Occur.MUST);
}
}
if (Random().NextBoolean()) // filtered case
{
childQuery2 = parentQuery2;
Filter f = new QueryWrapperFilter(new TermQuery(childTerm));
childFilter2 = Random().NextBoolean() ? new FixedBitSetCachingWrapperFilter(f) : f;
}
else
{
childFilter2 = null;
BooleanQuery bq2 = new BooleanQuery();
childQuery2 = bq2;
if (Random().NextBoolean())
{
bq2.Add(parentQuery2, BooleanClause.Occur.MUST);
bq2.Add(new TermQuery(childTerm), BooleanClause.Occur.MUST);
}
else
{
bq2.Add(new TermQuery(childTerm), BooleanClause.Occur.MUST);
bq2.Add(parentQuery2, BooleanClause.Occur.MUST);
}
}
}
Sort childSort2 = GetRandomSort("child", childFields.Length);
// Search denormalized index:
if (VERBOSE)
{
Console.WriteLine("TEST: run top down query=" + childQuery2 + " filter=" + childFilter2 + " sort=" + childSort2);
}
TopDocs results2 = s.Search(childQuery2, childFilter2, r.NumDocs, childSort2);
if (VERBOSE)
{
Console.WriteLine(" " + results2.TotalHits + " totalHits:");
foreach (ScoreDoc sd in results2.ScoreDocs)
{
Document doc = s.Doc(sd.Doc);
Console.WriteLine(" childID=" + doc.Get("childID") + " parentID=" + doc.Get("parentID") + " docID=" + sd.Doc);
}
}
// Search join index:
if (VERBOSE)
{
Console.WriteLine("TEST: run top down join query=" + childJoinQuery2 + " filter=" + childJoinFilter2 + " sort=" + childSort2);
}
TopDocs joinResults2 = joinS.Search(childJoinQuery2, childJoinFilter2, joinR.NumDocs, childSort2);
if (VERBOSE)
{
Console.WriteLine(" " + joinResults2.TotalHits + " totalHits:");
foreach (ScoreDoc sd in joinResults2.ScoreDocs)
{
Document doc = joinS.Doc(sd.Doc);
Document parentDoc = GetParentDoc(joinR, parentsFilter, sd.Doc);
Console.WriteLine(" childID=" + doc.Get("childID") + " parentID=" + parentDoc.Get("parentID") + " docID=" + sd.Doc);
}
}
CompareChildHits(r, joinR, results2, joinResults2);
}
r.Dispose();
joinR.Dispose();
dir.Dispose();
joinDir.Dispose();
}
public CachingWrapperFilterAnonymousInnerClassHelper(TestRangeFacetCounts outerInstance, QueryWrapperFilter org, AtomicBoolean filterWasUsed)
: base(org)
{
this.outerInstance = outerInstance;
this.filterWasUsed = filterWasUsed;
}
public virtual void TestEnforceDeletions()
{
Directory dir = NewDirectory();
RandomIndexWriter writer = new RandomIndexWriter(Random, dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random)).SetMergeScheduler(new SerialMergeScheduler()).SetMergePolicy(NewLogMergePolicy(10)));
// asserts below requires no unexpected merges:
// NOTE: cannot use writer.getReader because RIW (on
// flipping a coin) may give us a newly opened reader,
// but we use .reopen on this reader below and expect to
// (must) get an NRT reader:
DirectoryReader reader = DirectoryReader.Open(writer.IndexWriter, true);
// same reason we don't wrap?
IndexSearcher searcher = NewSearcher(
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
this,
#endif
reader, false);
// add a doc, refresh the reader, and check that it's there
Document doc = new Document();
doc.Add(NewStringField("id", "1", Field.Store.YES));
writer.AddDocument(doc);
reader = RefreshReader(reader);
searcher = NewSearcher(
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
this,
#endif
reader, false);
TopDocs docs = searcher.Search(new MatchAllDocsQuery(), 1);
Assert.AreEqual(1, docs.TotalHits, "Should find a hit...");
Filter startFilter = new QueryWrapperFilter(new TermQuery(new Term("id", "1")));
CachingWrapperFilter filter = new CachingWrapperFilter(startFilter);
docs = searcher.Search(new MatchAllDocsQuery(), filter, 1);
Assert.IsTrue(filter.GetSizeInBytes() > 0);
Assert.AreEqual(1, docs.TotalHits, "[query + filter] Should find a hit...");
Query constantScore = new ConstantScoreQuery(filter);
docs = searcher.Search(constantScore, 1);
Assert.AreEqual(1, docs.TotalHits, "[just filter] Should find a hit...");
// make sure we get a cache hit when we reopen reader
// that had no change to deletions
// fake delete (deletes nothing):
writer.DeleteDocuments(new Term("foo", "bar"));
IndexReader oldReader = reader;
reader = RefreshReader(reader);
Assert.IsTrue(reader == oldReader);
int missCount = filter.missCount;
docs = searcher.Search(constantScore, 1);
Assert.AreEqual(1, docs.TotalHits, "[just filter] Should find a hit...");
// cache hit:
Assert.AreEqual(missCount, filter.missCount);
// now delete the doc, refresh the reader, and see that it's not there
writer.DeleteDocuments(new Term("id", "1"));
// NOTE: important to hold ref here so GC doesn't clear
// the cache entry! Else the assert below may sometimes
// fail:
oldReader = reader;
reader = RefreshReader(reader);
searcher = NewSearcher(reader, false);
missCount = filter.missCount;
docs = searcher.Search(new MatchAllDocsQuery(), filter, 1);
Assert.AreEqual(0, docs.TotalHits, "[query + filter] Should *not* find a hit...");
// cache hit
Assert.AreEqual(missCount, filter.missCount);
docs = searcher.Search(constantScore, 1);
Assert.AreEqual(0, docs.TotalHits, "[just filter] Should *not* find a hit...");
// apply deletes dynamically:
filter = new CachingWrapperFilter(startFilter);
writer.AddDocument(doc);
reader = RefreshReader(reader);
searcher = NewSearcher(reader, false);
docs = searcher.Search(new MatchAllDocsQuery(), filter, 1);
Assert.AreEqual(1, docs.TotalHits, "[query + filter] Should find a hit...");
missCount = filter.missCount;
Assert.IsTrue(missCount > 0);
constantScore = new ConstantScoreQuery(filter);
docs = searcher.Search(constantScore, 1);
Assert.AreEqual(1, docs.TotalHits, "[just filter] Should find a hit...");
Assert.AreEqual(missCount, filter.missCount);
writer.AddDocument(doc);
// NOTE: important to hold ref here so GC doesn't clear
// the cache entry! Else the assert below may sometimes
// fail:
oldReader = reader;
reader = RefreshReader(reader);
searcher = NewSearcher(
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
this,
#endif
reader, false);
docs = searcher.Search(new MatchAllDocsQuery(), filter, 1);
Assert.AreEqual(2, docs.TotalHits, "[query + filter] Should find 2 hits...");
Assert.IsTrue(filter.missCount > missCount);
missCount = filter.missCount;
constantScore = new ConstantScoreQuery(filter);
docs = searcher.Search(constantScore, 1);
Assert.AreEqual(2, docs.TotalHits, "[just filter] Should find a hit...");
Assert.AreEqual(missCount, filter.missCount);
// now delete the doc, refresh the reader, and see that it's not there
writer.DeleteDocuments(new Term("id", "1"));
reader = RefreshReader(reader);
searcher = NewSearcher(
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
this,
#endif
reader, false);
docs = searcher.Search(new MatchAllDocsQuery(), filter, 1);
Assert.AreEqual(0, docs.TotalHits, "[query + filter] Should *not* find a hit...");
// CWF reused the same entry (it dynamically applied the deletes):
Assert.AreEqual(missCount, filter.missCount);
docs = searcher.Search(constantScore, 1);
Assert.AreEqual(0, docs.TotalHits, "[just filter] Should *not* find a hit...");
// CWF reused the same entry (it dynamically applied the deletes):
Assert.AreEqual(missCount, filter.missCount);
// NOTE: silliness to make sure JRE does not eliminate
// our holding onto oldReader to prevent
// CachingWrapperFilter's WeakHashMap from dropping the
// entry:
Assert.IsTrue(oldReader != null);
reader.Dispose();
writer.Dispose();
dir.Dispose();
}
public AnonymousClassHitCollector2(OpenBitSet bits, QueryWrapperFilter enclosingInstance)
{
InitBlock(bits, enclosingInstance);
}
