001: package org.apache.lucene.search;
002:
003: /**
004: * Licensed to the Apache Software Foundation (ASF) under one or more
005: * contributor license agreements. See the NOTICE file distributed with
006: * this work for additional information regarding copyright ownership.
007: * The ASF licenses this file to You under the Apache License, Version 2.0
008: * (the "License"); you may not use this file except in compliance with
009: * the License. You may obtain a copy of the License at
010: *
011: * http://www.apache.org/licenses/LICENSE-2.0
012: *
013: * Unless required by applicable law or agreed to in writing, software
014: * distributed under the License is distributed on an "AS IS" BASIS,
015: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
016: * See the License for the specific language governing permissions and
017: * limitations under the License.
018: */
019:
020: import java.io.IOException;
021: import java.util.BitSet;
022:
023: import org.apache.lucene.analysis.WhitespaceAnalyzer;
024: import org.apache.lucene.document.Document;
025: import org.apache.lucene.document.Field;
026: import org.apache.lucene.index.IndexReader;
027: import org.apache.lucene.index.IndexWriter;
028: import org.apache.lucene.index.Term;
029: import org.apache.lucene.search.BooleanClause;
030: import org.apache.lucene.search.BooleanFilter;
031: import org.apache.lucene.search.Filter;
032: import org.apache.lucene.search.FilterClause;
033: import org.apache.lucene.search.RangeFilter;
034: import org.apache.lucene.store.RAMDirectory;
035:
036: import junit.framework.TestCase;
037:
038: public class BooleanFilterTest extends TestCase {
039: private RAMDirectory directory;
040: private IndexReader reader;
041:
042: protected void setUp() throws Exception {
043: directory = new RAMDirectory();
044: IndexWriter writer = new IndexWriter(directory,
045: new WhitespaceAnalyzer(), true);
046:
047: //Add series of docs with filterable fields : acces rights, prices, dates and "in-stock" flags
048: addDoc(writer, "admin guest", "010", "20040101", "Y");
049: addDoc(writer, "guest", "020", "20040101", "Y");
050: addDoc(writer, "guest", "020", "20050101", "Y");
051: addDoc(writer, "admin", "020", "20050101", "Maybe");
052: addDoc(writer, "admin guest", "030", "20050101", "N");
053:
054: writer.close();
055: reader = IndexReader.open(directory);
056: }
057:
058: private void addDoc(IndexWriter writer, String accessRights,
059: String price, String date, String inStock)
060: throws IOException {
061: Document doc = new Document();
062: doc.add(new Field("accessRights", accessRights,
063: Field.Store.YES, Field.Index.TOKENIZED));
064: doc.add(new Field("price", price, Field.Store.YES,
065: Field.Index.TOKENIZED));
066: doc.add(new Field("date", date, Field.Store.YES,
067: Field.Index.TOKENIZED));
068: doc.add(new Field("inStock", inStock, Field.Store.YES,
069: Field.Index.TOKENIZED));
070: writer.addDocument(doc);
071: }
072:
073: private Filter getRangeFilter(String field, String lowerPrice,
074: String upperPrice) {
075: return new RangeFilter(field, lowerPrice, upperPrice, true,
076: true);
077: }
078:
079: private TermsFilter getTermsFilter(String field, String text) {
080: TermsFilter tf = new TermsFilter();
081: tf.addTerm(new Term(field, text));
082: return tf;
083: }
084:
085: public void testShould() throws Throwable {
086: BooleanFilter booleanFilter = new BooleanFilter();
087: booleanFilter.add(new FilterClause(getTermsFilter("price",
088: "030"), BooleanClause.Occur.SHOULD));
089: BitSet bits = booleanFilter.bits(reader);
090: assertEquals("Should retrieves only 1 doc", 1, bits
091: .cardinality());
092: }
093:
094: public void testShoulds() throws Throwable {
095: BooleanFilter booleanFilter = new BooleanFilter();
096: booleanFilter.add(new FilterClause(getRangeFilter("price",
097: "010", "020"), BooleanClause.Occur.SHOULD));
098: booleanFilter.add(new FilterClause(getRangeFilter("price",
099: "020", "030"), BooleanClause.Occur.SHOULD));
100: BitSet bits = booleanFilter.bits(reader);
101: assertEquals("Shoulds are Ored together", 5, bits.cardinality());
102: }
103:
104: public void testShouldsAndMustNot() throws Throwable {
105: BooleanFilter booleanFilter = new BooleanFilter();
106: booleanFilter.add(new FilterClause(getRangeFilter("price",
107: "010", "020"), BooleanClause.Occur.SHOULD));
108: booleanFilter.add(new FilterClause(getRangeFilter("price",
109: "020", "030"), BooleanClause.Occur.SHOULD));
110: booleanFilter.add(new FilterClause(getTermsFilter("inStock",
111: "N"), BooleanClause.Occur.MUST_NOT));
112: BitSet bits = booleanFilter.bits(reader);
113: assertEquals("Shoulds Ored but AndNot", 4, bits.cardinality());
114:
115: booleanFilter.add(new FilterClause(getTermsFilter("inStock",
116: "Maybe"), BooleanClause.Occur.MUST_NOT));
117: bits = booleanFilter.bits(reader);
118: assertEquals("Shoulds Ored but AndNots", 3, bits.cardinality());
119:
120: }
121:
122: public void testShouldsAndMust() throws Throwable {
123: BooleanFilter booleanFilter = new BooleanFilter();
124: booleanFilter.add(new FilterClause(getRangeFilter("price",
125: "010", "020"), BooleanClause.Occur.SHOULD));
126: booleanFilter.add(new FilterClause(getRangeFilter("price",
127: "020", "030"), BooleanClause.Occur.SHOULD));
128: booleanFilter.add(new FilterClause(getTermsFilter(
129: "accessRights", "admin"), BooleanClause.Occur.MUST));
130: BitSet bits = booleanFilter.bits(reader);
131: assertEquals("Shoulds Ored but MUST", 3, bits.cardinality());
132: }
133:
134: public void testShouldsAndMusts() throws Throwable {
135: BooleanFilter booleanFilter = new BooleanFilter();
136: booleanFilter.add(new FilterClause(getRangeFilter("price",
137: "010", "020"), BooleanClause.Occur.SHOULD));
138: booleanFilter.add(new FilterClause(getRangeFilter("price",
139: "020", "030"), BooleanClause.Occur.SHOULD));
140: booleanFilter.add(new FilterClause(getTermsFilter(
141: "accessRights", "admin"), BooleanClause.Occur.MUST));
142: booleanFilter.add(new FilterClause(getRangeFilter("date",
143: "20040101", "20041231"), BooleanClause.Occur.MUST));
144: BitSet bits = booleanFilter.bits(reader);
145: assertEquals("Shoulds Ored but MUSTs ANDED", 1, bits
146: .cardinality());
147: }
148:
149: public void testShouldsAndMustsAndMustNot() throws Throwable {
150: BooleanFilter booleanFilter = new BooleanFilter();
151: booleanFilter.add(new FilterClause(getRangeFilter("price",
152: "030", "040"), BooleanClause.Occur.SHOULD));
153: booleanFilter.add(new FilterClause(getTermsFilter(
154: "accessRights", "admin"), BooleanClause.Occur.MUST));
155: booleanFilter.add(new FilterClause(getRangeFilter("date",
156: "20050101", "20051231"), BooleanClause.Occur.MUST));
157: booleanFilter.add(new FilterClause(getTermsFilter("inStock",
158: "N"), BooleanClause.Occur.MUST_NOT));
159: BitSet bits = booleanFilter.bits(reader);
160: assertEquals("Shoulds Ored but MUSTs ANDED and MustNot", 0,
161: bits.cardinality());
162: }
163:
164: public void testJustMust() throws Throwable {
165: BooleanFilter booleanFilter = new BooleanFilter();
166: booleanFilter.add(new FilterClause(getTermsFilter(
167: "accessRights", "admin"), BooleanClause.Occur.MUST));
168: BitSet bits = booleanFilter.bits(reader);
169: assertEquals("MUST", 3, bits.cardinality());
170: }
171:
172: public void testJustMustNot() throws Throwable {
173: BooleanFilter booleanFilter = new BooleanFilter();
174: booleanFilter.add(new FilterClause(getTermsFilter("inStock",
175: "N"), BooleanClause.Occur.MUST_NOT));
176: BitSet bits = booleanFilter.bits(reader);
177: assertEquals("MUST_NOT", 4, bits.cardinality());
178: }
179:
180: public void testMustAndMustNot() throws Throwable {
181: BooleanFilter booleanFilter = new BooleanFilter();
182: booleanFilter.add(new FilterClause(getTermsFilter("inStock",
183: "N"), BooleanClause.Occur.MUST));
184: booleanFilter.add(new FilterClause(getTermsFilter("price",
185: "030"), BooleanClause.Occur.MUST_NOT));
186: BitSet bits = booleanFilter.bits(reader);
187: assertEquals("MUST_NOT wins over MUST for same docs", 0, bits
188: .cardinality());
189: }
190:
191: }
|