public virtual void TestSingleFilter()
{
ChainedFilter chain = GetChainedFilter(new Filter[] { dateFilter }, null);
int numHits = searcher.Search(query, chain, 1000).TotalHits;
assertEquals(Max, numHits);
chain = new ChainedFilter(new Filter[] { bobFilter });
numHits = searcher.Search(query, chain, 1000).TotalHits;
assertEquals(Max / 2, numHits);
chain = GetChainedFilter(new Filter[] { bobFilter }, new[] { ChainedFilter.AND });
TopDocs hits = searcher.Search(query, chain, 1000);
numHits = hits.TotalHits;
assertEquals(Max / 2, numHits);
assertEquals("bob", searcher.Doc(hits.ScoreDocs[0].Doc).Get("owner"));
chain = GetChainedFilter(new Filter[] { bobFilter }, new[] { ChainedFilter.ANDNOT });
hits = searcher.Search(query, chain, 1000);
numHits = hits.TotalHits;
assertEquals(Max / 2, numHits);
assertEquals("sue", searcher.Doc(hits.ScoreDocs[0].Doc).Get("owner"));
}
protected LuceneFilter GetFilter(Salary salary, bool excludeNoSalary)
{
int minSalary, maxSalary;
//Ensure salary is yearly before filtering
if (salary != null)
{
salary = salary.ToRate(SalaryRate.Year);
}
if (salary == null || !GetFilterFieldValues(salary.LowerBound, salary.UpperBound, out minSalary, out maxSalary) || (minSalary == 0 && maxSalary == int.MaxValue))
{
return(excludeNoSalary
? _nonNullSalaryFilter
: null);
}
var boundaryFilters = new List <LuceneFilter>(2);
if (minSalary != 0)
{
boundaryFilters.Add(FieldCacheRangeFilter.newIntRange(_maxFieldName, new java.lang.Integer(minSalary), null, true, true));
}
if (maxSalary != int.MaxValue)
{
boundaryFilters.Add(FieldCacheRangeFilter.newIntRange(_minFieldName, new java.lang.Integer(1), new java.lang.Integer(maxSalary), true, true));
}
var salaryFilter = new ChainedFilter(boundaryFilters.ToArray(), ChainedFilter.AND);
return(!excludeNoSalary
? new ChainedFilter(new[] { salaryFilter, _nullSalaryFilter }, ChainedFilter.OR)
: salaryFilter);
}
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 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 virtual void TestOR()
{
ChainedFilter chain = GetChainedFilter(new Filter[] { sueFilter, bobFilter }, null);
int numHits = searcher.Search(query, chain, 1000).TotalHits;
assertEquals("OR matches all", Max, numHits);
}
public virtual void TestXOR()
{
ChainedFilter chain = GetChainedFilter(new Filter[] { dateFilter, bobFilter }, ChainedFilter.XOR);
TopDocs hits = searcher.Search(query, chain, 1000);
assertEquals("XOR matches sue", Max / 2, hits.TotalHits);
assertEquals("sue", searcher.Doc(hits.ScoreDocs[0].Doc).Get("owner"));
}
Filter GetVisibilityFilter(string tenantId)
{
Filter tenantFilter;
if (tenantId != null && _filters.TryGetValue(tenantId, out tenantFilter))
{
Filter chainedFilter = new ChainedFilter(new Filter[] { _publicFilter, tenantFilter }, ChainedFilter.Logic.OR);
return(chainedFilter);
}
else
{
return(_publicFilter);
}
}
public virtual void TestANDNOT()
{
ChainedFilter chain = GetChainedFilter(new Filter[] { dateFilter, sueFilter }, new int[] { ChainedFilter.AND, ChainedFilter.ANDNOT });
TopDocs hits = searcher.Search(query, chain, 1000);
assertEquals("ANDNOT matches just bob", Max / 2, hits.TotalHits);
assertEquals("bob", searcher.Doc(hits.ScoreDocs[0].Doc).Get("owner"));
chain = GetChainedFilter(new Filter[] { bobFilter, bobFilter }, new int[] { ChainedFilter.ANDNOT, ChainedFilter.ANDNOT });
hits = searcher.Search(query, chain, 1000);
assertEquals("ANDNOT bob ANDNOT bob matches all sues", Max / 2, hits.TotalHits);
assertEquals("sue", searcher.Doc(hits.ScoreDocs[0].Doc).Get("owner"));
}
/// <exception cref="System.IO.IOException"></exception>
public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs
)
{
IBits docsWithField;
if (field == null)
{
docsWithField = null;
}
else
{
//all docs
//NOTE By using the FieldCache we re-use a cache
// which is nice but loading it in this way might be slower than say using an
// intersects filter against the world bounds. So do we add a method to the
// strategy, perhaps? But the strategy can't cache it.
docsWithField = FieldCache.DEFAULT.GetDocsWithField((context.AtomicReader), field);
int maxDoc = context.AtomicReader.MaxDoc;
if (docsWithField.Length != maxDoc)
{
throw new InvalidOperationException("Bits length should be maxDoc (" + maxDoc + ") but wasn't: "
+ docsWithField);
}
if (docsWithField is Bits.MatchNoBits)
{
return(null);
}
else
{
//match nothing
if (docsWithField is Bits.MatchAllBits)
{
docsWithField = null;
}
}
}
//all docs
//not so much a chain but a way to conveniently invert the Filter
DocIdSet docIdSet = new ChainedFilter(new[] { intersectsFilter }, ChainedFilter.ANDNOT).GetDocIdSet(context,
acceptDocs);
return(BitsFilteredDocIdSet.Wrap(docIdSet, docsWithField));
}
/// <exception cref="IOException"></exception>
public override DocIdSet?GetDocIdSet(AtomicReaderContext context, IBits?acceptDocs)
{
// LUCENENET specific - added guard clause
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
IBits?docsWithField;
if (field is null)
{
docsWithField = null;
}
else
{
//NOTE By using the FieldCache we re-use a cache
// which is nice but loading it in this way might be slower than say using an
// intersects filter against the world bounds. So do we add a method to the
// strategy, perhaps? But the strategy can't cache it.
docsWithField = FieldCache.DEFAULT.GetDocsWithField(context.AtomicReader, field);
int maxDoc = context.AtomicReader.MaxDoc;
if (docsWithField.Length != maxDoc)
{
throw IllegalStateException.Create("Bits length should be maxDoc (" + maxDoc + ") but wasn't: " + docsWithField);
}
if (docsWithField is Bits.MatchNoBits)
{
return(null);//match nothing
}
else if (docsWithField is Bits.MatchAllBits)
{
docsWithField = null;//all docs
}
}
//not so much a chain but a way to conveniently invert the Filter
DocIdSet docIdSet = new ChainedFilter(new Filter[] { intersectsFilter }, ChainedFilter.ANDNOT).GetDocIdSet(context, acceptDocs);
return(BitsFilteredDocIdSet.Wrap(docIdSet, docsWithField));
}
public bool TryGetFilter(bool includeUnlisted, bool includePrerelease, NuGetVersion semVerLevel, string curatedFeed, out Filter filter)
{
var includeSemVer2 = SemVerHelpers.ShouldIncludeSemVer2Results(semVerLevel);
LatestListedMask filterMask = (includeUnlisted ? LatestListedMask.IncludeUnlisted : 0) |
(includePrerelease ? LatestListedMask.IncludePrerelease : 0) |
(includeSemVer2 ? LatestListedMask.IncludeSemVer2 : 0);
Filter visibilityFilter = _latest[filterMask];
Filter curatedFeedFilter;
if (!string.IsNullOrEmpty(curatedFeed) && _curatedFeeds.TryGetValue(curatedFeed, out curatedFeedFilter))
{
filter = new ChainedFilter(new[] { visibilityFilter, curatedFeedFilter }, ChainedFilter.Logic.AND);
return(true);
}
filter = visibilityFilter;
return(true);
}
private ChainedFilter GetChainedFilter(Filter[] chain, ChainedFilter.Logic logic)
{
return new ChainedFilter(chain, logic);
}
private ChainedFilter GetChainedFilter(Filter[] chain, ChainedFilter.Logic[] logic)
{
if (logic == null)
{
return new ChainedFilter(chain);
}
else
{
return new ChainedFilter(chain, logic);
}
}
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 void TestSingleFilter()
{
ChainedFilter chain = GetChainedFilter(new Filter[] { dateFilter }, null);
int numHits = searcher.Search(query, chain, 1000).TotalHits;
Assert.AreEqual(MAX, numHits);
chain = new ChainedFilter(new Filter[] { bobFilter });
numHits = searcher.Search(query, chain, 1000).TotalHits;
Assert.AreEqual(MAX / 2, numHits);
chain = GetChainedFilter(new Filter[] { bobFilter }, new ChainedFilter.Logic[] { ChainedFilter.Logic.AND });
TopDocs hits = searcher.Search(query, chain, 1000);
numHits = hits.TotalHits;
Assert.AreEqual(MAX / 2, numHits);
Assert.AreEqual("bob", searcher.Doc(hits.ScoreDocs[0].Doc).Get("owner"));
chain = GetChainedFilter(new Filter[] { bobFilter }, new ChainedFilter.Logic[] { ChainedFilter.Logic.ANDNOT });
hits = searcher.Search(query, chain, 1000);
numHits = hits.TotalHits;
Assert.AreEqual(MAX / 2, numHits);
Assert.AreEqual("sue", searcher.Doc(hits.ScoreDocs[0].Doc).Get("owner"));
}
/// <exception cref="System.IO.IOException"></exception>
public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs
)
{
IBits docsWithField;
if (field == null)
{
docsWithField = null;
}
else
{
//all docs
//NOTE By using the FieldCache we re-use a cache
// which is nice but loading it in this way might be slower than say using an
// intersects filter against the world bounds. So do we add a method to the
// strategy, perhaps? But the strategy can't cache it.
docsWithField = FieldCache.DEFAULT.GetDocsWithField((context.AtomicReader), field);
int maxDoc = context.AtomicReader.MaxDoc;
if (docsWithField.Length != maxDoc)
{
throw new InvalidOperationException("Bits length should be maxDoc (" + maxDoc + ") but wasn't: "
+ docsWithField);
}
if (docsWithField is Bits.MatchNoBits)
{
return null;
}
else
{
//match nothing
if (docsWithField is Bits.MatchAllBits)
{
docsWithField = null;
}
}
}
//all docs
//not so much a chain but a way to conveniently invert the Filter
DocIdSet docIdSet = new ChainedFilter(new[] { intersectsFilter }, ChainedFilter.ANDNOT).GetDocIdSet(context,
acceptDocs);
return BitsFilteredDocIdSet.Wrap(docIdSet, docsWithField);
}
