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); }