Apache
/
lucene
mirror of https://github.com/apache/lucene.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

LUCENE-1957: Remove Filter.bits(IndexReader). 

git-svn-id: https://svn.apache.org/repos/asf/lucene/java/trunk@822930 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Michael Busch 2009-10-07 21:43:45 +00:00
parent f1bf7c01be
commit 39b4a0e4dc
14 changed files with 155 additions and 417 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGES.txt
View File

@ -31,6 +31,9 @@ API Changes
* LUCENE-1856: Remove Hits and all references from core and contrib.
(Michael Busch)
* LUCENE-1957: Remove Filter.bits(IndexReader) method and make
Filter.getDocIdSet(IndexReader) abstract. (Michael Busch)
Bug fixes
New features

2
common-build.xml
View File

@ -42,7 +42,7 @@
<property name="Name" value="Lucene"/>
<property name="dev.version" value="3.0-dev"/>
<property name="version" value="${dev.version}"/>
<property name="compatibility.tag" value="lucene_2_9_back_compat_tests_20091007a"/>
<property name="compatibility.tag" value="lucene_2_9_back_compat_tests_20091007b"/>
<property name="spec.version" value="${version}"/>
<property name="year" value="2000-${current.year}"/>
<property name="final.name" value="lucene-${name}-${version}"/>

185
contrib/misc/src/test/org/apache/lucene/misc/ChainedFilterTest.java
View File

@ -17,21 +17,31 @@ package org.apache.lucene.misc;
* limitations under the License.
*/
import junit.framework.TestCase;
import java.util.*;
import java.io.IOException;
import java.util.Calendar;
import junit.framework.TestCase;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.Term;
import org.apache.lucene.index.IndexWriter.MaxFieldLength;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.RAMDirectory;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.WhitespaceAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.search.*;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.Term;
import org.apache.lucene.index.IndexWriter.MaxFieldLength;
import org.apache.lucene.search.BooleanClause;
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.CachingWrapperFilter;
import org.apache.lucene.search.Filter;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.MatchAllDocsQuery;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.QueryWrapperFilter;
import org.apache.lucene.search.Searcher;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TermRangeFilter;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.RAMDirectory;
public class ChainedFilterTest extends TestCase {
public static final int MAX = 500;
@ -84,32 +94,7 @@ public class ChainedFilterTest extends TestCase {
new TermQuery(new Term("owner", "sue")));
}
private Filter[] getChainWithOldFilters(Filter[] chain) {
Filter[] oldFilters = new Filter[chain.length];
for (int i = 0; i < chain.length; i++) {
final Filter f = chain[i];
// create old BitSet-based Filter as wrapper
oldFilters[i] = new Filter() {
/** @deprecated */
public BitSet bits(IndexReader reader) throws IOException {
BitSet bits = new BitSet(reader.maxDoc());
DocIdSetIterator it = f.getDocIdSet(reader).iterator();
int doc;
while((doc = it.nextDoc()) != DocIdSetIterator.NO_MORE_DOCS) {
bits.set(doc);
}
return bits;
}
};
}
return oldFilters;
}
private ChainedFilter getChainedFilter(Filter[] chain, int[] logic, boolean old) {
if (old) {
chain = getChainWithOldFilters(chain);
}
private ChainedFilter getChainedFilter(Filter[] chain, int[] logic) {
if (logic == null) {
return new ChainedFilter(chain);
} else {
@ -117,98 +102,78 @@ public class ChainedFilterTest extends TestCase {
}
}
private ChainedFilter getChainedFilter(Filter[] chain, int logic, boolean old) {
if (old) {
chain = getChainWithOldFilters(chain);
}
private ChainedFilter getChainedFilter(Filter[] chain, int logic) {
return new ChainedFilter(chain, logic);
}
public void testSingleFilter() throws Exception {
for (int mode = 0; mode < 2; mode++) {
boolean old = (mode==0);
ChainedFilter chain = getChainedFilter(new Filter[] {dateFilter}, null, old);
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 int[] {ChainedFilter.AND}, old);
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 int[] {ChainedFilter.ANDNOT}, old);
hits = searcher.search(query, chain, 1000);
numHits = hits.totalHits;
assertEquals(MAX / 2, numHits);
assertEquals("sue", searcher.doc(hits.scoreDocs[0].doc).get("owner"));
}
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 int[] {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 int[] {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"));
}
public void testOR() throws Exception {
for (int mode = 0; mode < 2; mode++) {
boolean old = (mode==0);
ChainedFilter chain = getChainedFilter(
new Filter[] {sueFilter, bobFilter}, null, old);
int numHits = searcher.search(query, chain, 1000).totalHits;
assertEquals("OR matches all", MAX, numHits);
}
ChainedFilter chain = getChainedFilter(
new Filter[] {sueFilter, bobFilter}, null);
int numHits = searcher.search(query, chain, 1000).totalHits;
assertEquals("OR matches all", MAX, numHits);
}
public void testAND() throws Exception {
for (int mode = 0; mode < 2; mode++) {
boolean old = (mode==0);
ChainedFilter chain = getChainedFilter(
new Filter[] {dateFilter, bobFilter}, ChainedFilter.AND, old);
TopDocs hits = searcher.search(query, chain, 1000);
assertEquals("AND matches just bob", MAX / 2, hits.totalHits);
assertEquals("bob", searcher.doc(hits.scoreDocs[0].doc).get("owner"));
}
ChainedFilter chain = getChainedFilter(
new Filter[] {dateFilter, bobFilter}, ChainedFilter.AND);
TopDocs hits = searcher.search(query, chain, 1000);
assertEquals("AND matches just bob", MAX / 2, hits.totalHits);
assertEquals("bob", searcher.doc(hits.scoreDocs[0].doc).get("owner"));
}
public void testXOR() throws Exception {
for (int mode = 0; mode < 2; mode++) {
boolean old = (mode==0);
ChainedFilter chain = getChainedFilter(
new Filter[]{dateFilter, bobFilter}, ChainedFilter.XOR, old);
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"));
}
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"));
}
public void testANDNOT() throws Exception {
for (int mode = 0; mode < 2; mode++) {
boolean old = (mode==0);
ChainedFilter chain = getChainedFilter(
new Filter[]{dateFilter, sueFilter},
new int[] {ChainedFilter.AND, ChainedFilter.ANDNOT}, old);
TopDocs hits = searcher.search(query, chain, 1000);
assertEquals("ANDNOT matches just bob",
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("bob", searcher.doc(hits.scoreDocs[0].doc).get("owner"));
chain = getChainedFilter(
new Filter[]{bobFilter, bobFilter},
new int[] {ChainedFilter.ANDNOT, ChainedFilter.ANDNOT}, old);
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"));
}
assertEquals("sue", searcher.doc(hits.scoreDocs[0].doc).get("owner"));
}
/*

30
contrib/queries/src/java/org/apache/lucene/search/TermsFilter.java
View File

@ -49,36 +49,6 @@ public class TermsFilter extends Filter
terms.add(term);
}
/* (non-Javadoc)
* @see org.apache.lucene.search.Filter#bits(org.apache.lucene.index.IndexReader)
*/
public BitSet bits(IndexReader reader) throws IOException
{
BitSet result=new BitSet(reader.maxDoc());
TermDocs td = reader.termDocs();
try
{
for (Iterator iter = terms.iterator(); iter.hasNext();)
{
Term term = (Term) iter.next();
td.seek(term);
while (td.next())
{
result.set(td.doc());
}
}
}
finally
{
td.close();
}
return result;
}
/* (non-Javadoc)
* @see org.apache.lucene.search.Filter#getDocIdSet(org.apache.lucene.index.IndexReader)
*/

153
contrib/queries/src/test/org/apache/lucene/search/BooleanFilterTest.java
View File

@ -18,7 +18,8 @@ package org.apache.lucene.search;
*/
import java.io.IOException;
import java.util.BitSet;
import junit.framework.TestCase;
import org.apache.lucene.analysis.WhitespaceAnalyzer;
import org.apache.lucene.document.Document;
@ -26,15 +27,7 @@ import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.BooleanClause;
import org.apache.lucene.search.BooleanFilter;
import org.apache.lucene.search.Filter;
import org.apache.lucene.search.FilterClause;
import org.apache.lucene.search.TermRangeFilter;
import org.apache.lucene.store.RAMDirectory;
import org.apache.lucene.util.DocIdBitSet;
import junit.framework.TestCase;
public class BooleanFilterTest extends TestCase
{
@ -67,37 +60,15 @@ public class BooleanFilterTest extends TestCase
writer.addDocument(doc);
}
private Filter getOldBitSetFilter(final Filter filter) {
return new Filter() {
public BitSet bits(IndexReader reader) throws IOException {
BitSet bits = new BitSet(reader.maxDoc());
DocIdSetIterator it = filter.getDocIdSet(reader).iterator();
while(it.next()) {
bits.set(it.doc());
}
return bits;
}
};
}
private Filter getRangeFilter(String field,String lowerPrice, String upperPrice, boolean old)
private Filter getRangeFilter(String field,String lowerPrice, String upperPrice)
{
Filter f = new TermRangeFilter(field,lowerPrice,upperPrice,true,true);
if (old) {
return getOldBitSetFilter(f);
}
return f;
}
private Filter getTermsFilter(String field,String text, boolean old)
private Filter getTermsFilter(String field,String text)
{
TermsFilter tf=new TermsFilter();
tf.addTerm(new Term(field,text));
if (old) {
return getOldBitSetFilter(tf);
}
return tf;
}
@ -116,107 +87,73 @@ public class BooleanFilterTest extends TestCase
public void testShould() throws Throwable
{
for (int i = 0; i < 2; i++) {
boolean old = (i==0);
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.add(new FilterClause(getTermsFilter("price","030", old),BooleanClause.Occur.SHOULD));
tstFilterCard("Should retrieves only 1 doc",1,booleanFilter);
}
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.add(new FilterClause(getTermsFilter("price","030"),BooleanClause.Occur.SHOULD));
tstFilterCard("Should retrieves only 1 doc",1,booleanFilter);
}
public void testShoulds() throws Throwable
{
for (int i = 0; i < 2; i++) {
boolean old = (i==0);
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.add(new FilterClause(getRangeFilter("price","010", "020", old),BooleanClause.Occur.SHOULD));
booleanFilter.add(new FilterClause(getRangeFilter("price","020", "030", old),BooleanClause.Occur.SHOULD));
tstFilterCard("Shoulds are Ored together",5,booleanFilter);
}
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.add(new FilterClause(getRangeFilter("price","010", "020"),BooleanClause.Occur.SHOULD));
booleanFilter.add(new FilterClause(getRangeFilter("price","020", "030"),BooleanClause.Occur.SHOULD));
tstFilterCard("Shoulds are Ored together",5,booleanFilter);
}
public void testShouldsAndMustNot() throws Throwable
{
for (int i = 0; i < 2; i++) {
boolean old = (i==0);
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.add(new FilterClause(getRangeFilter("price","010", "020"),BooleanClause.Occur.SHOULD));
booleanFilter.add(new FilterClause(getRangeFilter("price","020", "030"),BooleanClause.Occur.SHOULD));
booleanFilter.add(new FilterClause(getTermsFilter("inStock", "N"),BooleanClause.Occur.MUST_NOT));
tstFilterCard("Shoulds Ored but AndNot",4,booleanFilter);
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.add(new FilterClause(getRangeFilter("price","010", "020", old),BooleanClause.Occur.SHOULD));
booleanFilter.add(new FilterClause(getRangeFilter("price","020", "030", old),BooleanClause.Occur.SHOULD));
booleanFilter.add(new FilterClause(getTermsFilter("inStock", "N", old),BooleanClause.Occur.MUST_NOT));
tstFilterCard("Shoulds Ored but AndNot",4,booleanFilter);
booleanFilter.add(new FilterClause(getTermsFilter("inStock", "Maybe", old),BooleanClause.Occur.MUST_NOT));
tstFilterCard("Shoulds Ored but AndNots",3,booleanFilter);
}
booleanFilter.add(new FilterClause(getTermsFilter("inStock", "Maybe"),BooleanClause.Occur.MUST_NOT));
tstFilterCard("Shoulds Ored but AndNots",3,booleanFilter);
}
public void testShouldsAndMust() throws Throwable
{
for (int i = 0; i < 2; i++) {
boolean old = (i==0);
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.add(new FilterClause(getRangeFilter("price","010", "020", old),BooleanClause.Occur.SHOULD));
booleanFilter.add(new FilterClause(getRangeFilter("price","020", "030", old),BooleanClause.Occur.SHOULD));
booleanFilter.add(new FilterClause(getTermsFilter("accessRights", "admin", old),BooleanClause.Occur.MUST));
tstFilterCard("Shoulds Ored but MUST",3,booleanFilter);
}
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.add(new FilterClause(getRangeFilter("price","010", "020"),BooleanClause.Occur.SHOULD));
booleanFilter.add(new FilterClause(getRangeFilter("price","020", "030"),BooleanClause.Occur.SHOULD));
booleanFilter.add(new FilterClause(getTermsFilter("accessRights", "admin"),BooleanClause.Occur.MUST));
tstFilterCard("Shoulds Ored but MUST",3,booleanFilter);
}
public void testShouldsAndMusts() throws Throwable
{
for (int i = 0; i < 2; i++) {
boolean old = (i==0);
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.add(new FilterClause(getRangeFilter("price","010", "020", old),BooleanClause.Occur.SHOULD));
booleanFilter.add(new FilterClause(getRangeFilter("price","020", "030", old),BooleanClause.Occur.SHOULD));
booleanFilter.add(new FilterClause(getTermsFilter("accessRights", "admin", old),BooleanClause.Occur.MUST));
booleanFilter.add(new FilterClause(getRangeFilter("date","20040101", "20041231", old),BooleanClause.Occur.MUST));
tstFilterCard("Shoulds Ored but MUSTs ANDED",1,booleanFilter);
}
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.add(new FilterClause(getRangeFilter("price","010", "020"),BooleanClause.Occur.SHOULD));
booleanFilter.add(new FilterClause(getRangeFilter("price","020", "030"),BooleanClause.Occur.SHOULD));
booleanFilter.add(new FilterClause(getTermsFilter("accessRights", "admin"),BooleanClause.Occur.MUST));
booleanFilter.add(new FilterClause(getRangeFilter("date","20040101", "20041231"),BooleanClause.Occur.MUST));
tstFilterCard("Shoulds Ored but MUSTs ANDED",1,booleanFilter);
}
public void testShouldsAndMustsAndMustNot() throws Throwable
{
for (int i = 0; i < 2; i++) {
boolean old = (i==0);
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.add(new FilterClause(getRangeFilter("price","030", "040", old),BooleanClause.Occur.SHOULD));
booleanFilter.add(new FilterClause(getTermsFilter("accessRights", "admin", old),BooleanClause.Occur.MUST));
booleanFilter.add(new FilterClause(getRangeFilter("date","20050101", "20051231", old),BooleanClause.Occur.MUST));
booleanFilter.add(new FilterClause(getTermsFilter("inStock","N", old),BooleanClause.Occur.MUST_NOT));
tstFilterCard("Shoulds Ored but MUSTs ANDED and MustNot",0,booleanFilter);
}
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.add(new FilterClause(getRangeFilter("price","030", "040"),BooleanClause.Occur.SHOULD));
booleanFilter.add(new FilterClause(getTermsFilter("accessRights", "admin"),BooleanClause.Occur.MUST));
booleanFilter.add(new FilterClause(getRangeFilter("date","20050101", "20051231"),BooleanClause.Occur.MUST));
booleanFilter.add(new FilterClause(getTermsFilter("inStock","N"),BooleanClause.Occur.MUST_NOT));
tstFilterCard("Shoulds Ored but MUSTs ANDED and MustNot",0,booleanFilter);
}
public void testJustMust() throws Throwable
{
for (int i = 0; i < 2; i++) {
boolean old = (i==0);
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.add(new FilterClause(getTermsFilter("accessRights", "admin", old),BooleanClause.Occur.MUST));
tstFilterCard("MUST",3,booleanFilter);
}
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.add(new FilterClause(getTermsFilter("accessRights", "admin"),BooleanClause.Occur.MUST));
tstFilterCard("MUST",3,booleanFilter);
}
public void testJustMustNot() throws Throwable
{
for (int i = 0; i < 2; i++) {
boolean old = (i==0);
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.add(new FilterClause(getTermsFilter("inStock","N", old),BooleanClause.Occur.MUST_NOT));
tstFilterCard("MUST_NOT",4,booleanFilter);
}
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.add(new FilterClause(getTermsFilter("inStock","N"),BooleanClause.Occur.MUST_NOT));
tstFilterCard("MUST_NOT",4,booleanFilter);
}
public void testMustAndMustNot() throws Throwable
{
for (int i = 0; i < 2; i++) {
boolean old = (i==0);
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.add(new FilterClause(getTermsFilter("inStock","N", old),BooleanClause.Occur.MUST));
booleanFilter.add(new FilterClause(getTermsFilter("price","030", old),BooleanClause.Occur.MUST_NOT));
tstFilterCard("MUST_NOT wins over MUST for same docs",0,booleanFilter);
}
BooleanFilter booleanFilter = new BooleanFilter();
booleanFilter.add(new FilterClause(getTermsFilter("inStock","N"),BooleanClause.Occur.MUST));
booleanFilter.add(new FilterClause(getTermsFilter("price","030"),BooleanClause.Occur.MUST_NOT));
tstFilterCard("MUST_NOT wins over MUST for same docs",0,booleanFilter);
}
}

13
contrib/remote/src/java/org/apache/lucene/search/RemoteCachingWrapperFilter.java
View File

@ -18,7 +18,6 @@ package org.apache.lucene.search;
*/
import java.io.IOException;
import java.util.BitSet;
import org.apache.lucene.index.IndexReader;
@ -45,18 +44,6 @@ public class RemoteCachingWrapperFilter extends Filter {
public RemoteCachingWrapperFilter(Filter filter) {
this.filter = filter;
}
/**
* Uses the {@link org.apache.lucene.search.FilterManager} to keep the cache for a filter on the
* searcher side of a remote connection.
* @param reader the index reader for the Filter
* @return the bitset
* @deprecated Use {@link #getDocIdSet(IndexReader)} instead.
*/
public BitSet bits(IndexReader reader) throws IOException {
Filter cachedFilter = FilterManager.getInstance().getFilter(filter);
return cachedFilter.bits(reader);
}
/**
* Uses the {@link org.apache.lucene.search.FilterManager} to keep the cache for a filter on the

8
src/java/org/apache/lucene/search/CachingSpanFilter.java
View File

@ -42,14 +42,6 @@ public class CachingSpanFilter extends SpanFilter {
this.filter = filter;
}
/**
* @deprecated Use {@link #getDocIdSet(IndexReader)} instead.
*/
public BitSet bits(IndexReader reader) throws IOException {
SpanFilterResult result = getCachedResult(reader);
return result != null ? result.getBits() : null;
}
public DocIdSet getDocIdSet(IndexReader reader) throws IOException {
SpanFilterResult result = getCachedResult(reader);
return result != null ? result.getDocIdSet() : null;

52
src/java/org/apache/lucene/search/CachingWrapperFilter.java
View File

@ -17,13 +17,12 @@ package org.apache.lucene.search;
* limitations under the License.
*/
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.util.DocIdBitSet;
import org.apache.lucene.util.OpenBitSetDISI;
import java.util.BitSet;
import java.util.WeakHashMap;
import java.util.Map;
import java.io.IOException;
import java.util.Map;
import java.util.WeakHashMap;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.util.OpenBitSetDISI;
/**
* Wraps another filter's result and caches it. The purpose is to allow
@ -35,7 +34,7 @@ public class CachingWrapperFilter extends Filter {
/**
* A transient Filter cache.
*/
protected transient Map cache;
protected transient Map<IndexReader, DocIdSet> cache;
/**
* @param filter Filter to cache results of
@ -44,36 +43,6 @@ public class CachingWrapperFilter extends Filter {
this.filter = filter;
}
/**
* @deprecated Use {@link #getDocIdSet(IndexReader)} instead.
*/
public BitSet bits(IndexReader reader) throws IOException {
if (cache == null) {
cache = new WeakHashMap();
}
Object cached = null;
synchronized (cache) { // check cache
cached = cache.get(reader);
}
if (cached != null) {
if (cached instanceof BitSet) {
return (BitSet) cached;
} else if (cached instanceof DocIdBitSet)
return ((DocIdBitSet) cached).getBitSet();
// It would be nice to handle the DocIdSet case, but that's not really possible
}
final BitSet bits = filter.bits(reader);
synchronized (cache) { // update cache
cache.put(reader, bits);
}
return bits;
}
/** Provide the DocIdSet to be cached, using the DocIdSet provided
* by the wrapped Filter.
* <p>This implementation returns the given {@link DocIdSet}, if {@link DocIdSet#isCacheable}
@ -94,19 +63,16 @@ public class CachingWrapperFilter extends Filter {
public DocIdSet getDocIdSet(IndexReader reader) throws IOException {
if (cache == null) {
cache = new WeakHashMap();
cache = new WeakHashMap<IndexReader, DocIdSet>();
}
Object cached = null;
DocIdSet cached = null;
synchronized (cache) { // check cache
cached = cache.get(reader);
}
if (cached != null) {
if (cached instanceof DocIdSet)
return (DocIdSet) cached;
else
return new DocIdBitSet((BitSet) cached);
return (DocIdSet) cached;
}
final DocIdSet docIdSet = docIdSetToCache(filter.getDocIdSet(reader), reader);

19
src/java/org/apache/lucene/search/Filter.java
View File

@ -17,29 +17,16 @@ package org.apache.lucene.search;
* limitations under the License.
*/
import java.util.BitSet;
import java.io.IOException;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.util.DocIdBitSet;
/** Abstract base class providing a mechanism to use a subset of an index
* for restriction or permission of index search results.
* <p>
* <b>Note:</b> In Lucene 3.0 {@link #bits(IndexReader)} will be removed
* and {@link #getDocIdSet(IndexReader)} will be defined as abstract.
* All implementing classes must therefore implement {@link #getDocIdSet(IndexReader)}
* in order to work with Lucene 3.0.
*/
public abstract class Filter implements java.io.Serializable {
/**
* @return A BitSet with true for documents which should be permitted in
* search results, and false for those that should not.
* @deprecated Use {@link #getDocIdSet(IndexReader)} instead.
*/
public BitSet bits(IndexReader reader) throws IOException {
throw new UnsupportedOperationException();
}
/**
* @return a DocIdSet that provides the documents which should be permitted or
* prohibited in search results. <b>NOTE:</b> null can be returned if
@ -47,7 +34,5 @@ public abstract class Filter implements java.io.Serializable {
*
* @see DocIdBitSet
*/
public DocIdSet getDocIdSet(IndexReader reader) throws IOException {
return new DocIdBitSet(bits(reader));
}
public abstract DocIdSet getDocIdSet(IndexReader reader) throws IOException;
}

27
src/java/org/apache/lucene/search/MultiTermQueryWrapperFilter.java
View File

@ -17,15 +17,14 @@ package org.apache.lucene.search;
* limitations under the License.
*/
import java.io.IOException;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.index.TermDocs;
import org.apache.lucene.index.TermEnum;
import org.apache.lucene.util.OpenBitSet;
import java.io.IOException;
import java.util.BitSet;
/**
* A wrapper for {@link MultiTermQuery}, that exposes its
* functionality as a {@link Filter}.
@ -129,28 +128,6 @@ public class MultiTermQueryWrapperFilter extends Filter {
abstract public void handleDoc(int doc);
}
/**
* Returns a BitSet with true for documents which should be
* permitted in search results, and false for those that should
* not.
* @deprecated Use {@link #getDocIdSet(IndexReader)} instead.
*/
@Override
public BitSet bits(IndexReader reader) throws IOException {
final TermEnum enumerator = query.getEnum(reader);
try {
final BitSet bitSet = new BitSet(reader.maxDoc());
new TermGenerator() {
public void handleDoc(int doc) {
bitSet.set(doc);
}
}.generate(reader, enumerator);
return bitSet;
} finally {
enumerator.close();
}
}
/**
* Returns a DocIdSet with documents that should be
* permitted in search results.

24
src/java/org/apache/lucene/search/QueryWrapperFilter.java
View File

@ -44,30 +44,6 @@ public class QueryWrapperFilter extends Filter {
this.query = query;
}
/**
* @deprecated Use {@link #getDocIdSet(IndexReader)} instead.
*/
public BitSet bits(IndexReader reader) throws IOException {
final BitSet bits = new BitSet(reader.maxDoc());
new IndexSearcher(reader).search(query, new Collector() {
private int base = 0;
public void setScorer(Scorer scorer) throws IOException {
// score is not needed by this collector
}
public final void collect(int doc) {
bits.set(doc + base); // set bit for hit
}
public void setNextReader(IndexReader reader, int docBase) {
base = docBase;
}
public boolean acceptsDocsOutOfOrder() {
return true;
}
});
return bits;
}
public DocIdSet getDocIdSet(final IndexReader reader) throws IOException {
final Weight weight = query.weight(new IndexSearcher(reader));
return new DocIdSet() {

21
src/java/org/apache/lucene/search/SpanFilterResult.java
View File

@ -28,22 +28,8 @@ import java.util.List;
*
**/
public class SpanFilterResult {
/** @deprecated */
private BitSet bits;
private DocIdSet docIdSet;
private List positions;//Spans spans;
/**
*
* @param bits The bits for the Filter
* @param positions A List of {@link org.apache.lucene.search.SpanFilterResult.PositionInfo} objects
* @deprecated Use {@link #SpanFilterResult(DocIdSet, List)} instead
*/
public SpanFilterResult(BitSet bits, List positions) {
this.bits = bits;
this.positions = positions;
}
/**
*
@ -64,13 +50,6 @@ public class SpanFilterResult {
return positions;
}
/**
* @deprecated Use {@link #getDocIdSet()}
*/
public BitSet getBits() {
return bits;
}
/** Returns the docIdSet */
public DocIdSet getDocIdSet() {
return docIdSet;

9
src/test/org/apache/lucene/search/JustCompileSearch.java
View File

@ -244,6 +244,11 @@ final class JustCompileSearch {
static final class JustCompileFilter extends Filter {
// Filter is just an abstract class with no abstract methods. However it is
// still added here in case someone will add abstract methods in the future.
@Override
public DocIdSet getDocIdSet(IndexReader reader) throws IOException {
return null;
}
}
static final class JustCompileFilteredDocIdSet extends FilteredDocIdSet {
@ -396,6 +401,10 @@ final class JustCompileSearch {
throw new UnsupportedOperationException(UNSUPPORTED_MSG);
}
@Override
public DocIdSet getDocIdSet(IndexReader reader) throws IOException {
return null;
}
}
static final class JustCompileTopDocsCollector extends TopDocsCollector {

26
src/test/org/apache/lucene/search/TestCachingWrapperFilter.java
View File

@ -17,18 +17,17 @@ package org.apache.lucene.search;
* limitations under the License.
*/
import org.apache.lucene.util.LuceneTestCase;
import org.apache.lucene.util.OpenBitSet;
import org.apache.lucene.util.OpenBitSetDISI;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.RAMDirectory;
import java.io.IOException;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.Term;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import java.io.IOException;
import java.util.BitSet;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.RAMDirectory;
import org.apache.lucene.util.LuceneTestCase;
import org.apache.lucene.util.OpenBitSet;
import org.apache.lucene.util.OpenBitSetDISI;
public class TestCachingWrapperFilter extends LuceneTestCase {
public void testCachingWorks() throws Exception {
@ -45,8 +44,7 @@ public class TestCachingWrapperFilter extends LuceneTestCase {
cacher.getDocIdSet(reader);
assertTrue("first time", filter.wasCalled());
// make sure no exception if cache is holding the wrong bitset
cacher.bits(reader);
// make sure no exception if cache is holding the wrong docIdSet
cacher.getDocIdSet(reader);
// second time, nested filter should not be called
@ -90,12 +88,6 @@ public class TestCachingWrapperFilter extends LuceneTestCase {
return new OpenBitSet();
}
}, true);
// a deprecated filter is always cacheable
assertDocIdSetCacheable(reader, new Filter() {
public BitSet bits(IndexReader reader) {
return new BitSet();
}
}, true);
reader.close();
}