1 package org.apache.lucene.search.spans;
4 * Licensed to the Apache Software Foundation (ASF) under one or more
5 * contributor license agreements. See the NOTICE file distributed with
6 * this work for additional information regarding copyright ownership.
7 * The ASF licenses this file to You under the Apache License, Version 2.0
8 * (the "License"); you may not use this file except in compliance with
9 * the License. You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
20 import java.util.HashSet;
23 import org.apache.lucene.analysis.MockAnalyzer;
24 import org.apache.lucene.document.Document;
25 import org.apache.lucene.document.Field;
26 import org.apache.lucene.index.IndexReader;
27 import org.apache.lucene.index.RandomIndexWriter;
28 import org.apache.lucene.index.Term;
29 import org.apache.lucene.search.CheckHits;
30 import org.apache.lucene.search.IndexSearcher;
31 import org.apache.lucene.search.Query;
32 import org.apache.lucene.search.QueryUtils;
33 import org.apache.lucene.store.Directory;
34 import org.apache.lucene.util.LuceneTestCase;
35 import org.junit.AfterClass;
36 import org.junit.BeforeClass;
38 public class TestFieldMaskingSpanQuery extends LuceneTestCase {
40 protected static Document doc(Field[] fields) {
41 Document doc = new Document();
42 for (int i = 0; i < fields.length; i++) {
48 protected static Field field(String name, String value) {
49 return newField(name, value, Field.Store.NO, Field.Index.ANALYZED);
52 protected static IndexSearcher searcher;
53 protected static Directory directory;
54 protected static IndexReader reader;
57 public static void beforeClass() throws Exception {
58 directory = newDirectory();
59 RandomIndexWriter writer= new RandomIndexWriter(random, directory, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)).setMergePolicy(newLogMergePolicy()));
61 writer.addDocument(doc(new Field[] { field("id", "0")
63 field("gender", "male"),
64 field("first", "james"),
65 field("last", "jones") }));
67 writer.addDocument(doc(new Field[] { field("id", "1")
69 field("gender", "male"),
70 field("first", "james"),
71 field("last", "smith")
73 field("gender", "female"),
74 field("first", "sally"),
75 field("last", "jones") }));
77 writer.addDocument(doc(new Field[] { field("id", "2")
79 field("gender", "female"),
80 field("first", "greta"),
81 field("last", "jones")
83 field("gender", "female"),
84 field("first", "sally"),
85 field("last", "smith")
87 field("gender", "male"),
88 field("first", "james"),
89 field("last", "jones") }));
91 writer.addDocument(doc(new Field[] { field("id", "3")
93 field("gender", "female"),
94 field("first", "lisa"),
95 field("last", "jones")
97 field("gender", "male"),
98 field("first", "bob"),
99 field("last", "costas") }));
101 writer.addDocument(doc(new Field[] { field("id", "4")
103 field("gender", "female"),
104 field("first", "sally"),
105 field("last", "smith")
107 field("gender", "female"),
108 field("first", "linda"),
109 field("last", "dixit")
111 field("gender", "male"),
112 field("first", "bubba"),
113 field("last", "jones") }));
114 reader = writer.getReader();
116 searcher = newSearcher(reader);
120 public static void afterClass() throws Exception {
129 protected void check(SpanQuery q, int[] docs) throws Exception {
130 CheckHits.checkHitCollector(random, q, null, searcher, docs);
133 public void testRewrite0() throws Exception {
134 SpanQuery q = new FieldMaskingSpanQuery
135 (new SpanTermQuery(new Term("last", "sally")) , "first");
136 q.setBoost(8.7654321f);
137 SpanQuery qr = (SpanQuery) searcher.rewrite(q);
139 QueryUtils.checkEqual(q, qr);
141 Set<Term> terms = new HashSet<Term>();
142 qr.extractTerms(terms);
143 assertEquals(1, terms.size());
146 public void testRewrite1() throws Exception {
147 // mask an anon SpanQuery class that rewrites to something else.
148 SpanQuery q = new FieldMaskingSpanQuery
149 (new SpanTermQuery(new Term("last", "sally")) {
151 public Query rewrite(IndexReader reader) {
152 return new SpanOrQuery(new SpanQuery[] {
153 new SpanTermQuery(new Term("first", "sally")),
154 new SpanTermQuery(new Term("first", "james")) });
158 SpanQuery qr = (SpanQuery) searcher.rewrite(q);
160 QueryUtils.checkUnequal(q, qr);
162 Set<Term> terms = new HashSet<Term>();
163 qr.extractTerms(terms);
164 assertEquals(2, terms.size());
167 public void testRewrite2() throws Exception {
168 SpanQuery q1 = new SpanTermQuery(new Term("last", "smith"));
169 SpanQuery q2 = new SpanTermQuery(new Term("last", "jones"));
170 SpanQuery q = new SpanNearQuery(new SpanQuery[]
171 { q1, new FieldMaskingSpanQuery(q2, "last")}, 1, true );
172 Query qr = searcher.rewrite(q);
174 QueryUtils.checkEqual(q, qr);
176 HashSet<Term> set = new HashSet<Term>();
177 qr.extractTerms(set);
178 assertEquals(2, set.size());
181 public void testEquality1() {
182 SpanQuery q1 = new FieldMaskingSpanQuery
183 (new SpanTermQuery(new Term("last", "sally")) , "first");
184 SpanQuery q2 = new FieldMaskingSpanQuery
185 (new SpanTermQuery(new Term("last", "sally")) , "first");
186 SpanQuery q3 = new FieldMaskingSpanQuery
187 (new SpanTermQuery(new Term("last", "sally")) , "XXXXX");
188 SpanQuery q4 = new FieldMaskingSpanQuery
189 (new SpanTermQuery(new Term("last", "XXXXX")) , "first");
190 SpanQuery q5 = new FieldMaskingSpanQuery
191 (new SpanTermQuery(new Term("xXXX", "sally")) , "first");
192 QueryUtils.checkEqual(q1, q2);
193 QueryUtils.checkUnequal(q1, q3);
194 QueryUtils.checkUnequal(q1, q4);
195 QueryUtils.checkUnequal(q1, q5);
197 SpanQuery qA = new FieldMaskingSpanQuery
198 (new SpanTermQuery(new Term("last", "sally")) , "first");
200 SpanQuery qB = new FieldMaskingSpanQuery
201 (new SpanTermQuery(new Term("last", "sally")) , "first");
202 QueryUtils.checkUnequal(qA, qB);
204 QueryUtils.checkEqual(qA, qB);
208 public void testNoop0() throws Exception {
209 SpanQuery q1 = new SpanTermQuery(new Term("last", "sally"));
210 SpanQuery q = new FieldMaskingSpanQuery(q1, "first");
211 check(q, new int[] { /* :EMPTY: */ });
213 public void testNoop1() throws Exception {
214 SpanQuery q1 = new SpanTermQuery(new Term("last", "smith"));
215 SpanQuery q2 = new SpanTermQuery(new Term("last", "jones"));
216 SpanQuery q = new SpanNearQuery(new SpanQuery[]
217 { q1, new FieldMaskingSpanQuery(q2, "last")}, 0, true );
218 check(q, new int[] { 1, 2 });
219 q = new SpanNearQuery(new SpanQuery[]
220 { new FieldMaskingSpanQuery(q1, "last"),
221 new FieldMaskingSpanQuery(q2, "last")}, 0, true );
222 check(q, new int[] { 1, 2 });
225 public void testSimple1() throws Exception {
226 SpanQuery q1 = new SpanTermQuery(new Term("first", "james"));
227 SpanQuery q2 = new SpanTermQuery(new Term("last", "jones"));
228 SpanQuery q = new SpanNearQuery(new SpanQuery[]
229 { q1, new FieldMaskingSpanQuery(q2, "first")}, -1, false );
230 check(q, new int[] { 0, 2 });
231 q = new SpanNearQuery(new SpanQuery[]
232 { new FieldMaskingSpanQuery(q2, "first"), q1}, -1, false );
233 check(q, new int[] { 0, 2 });
234 q = new SpanNearQuery(new SpanQuery[]
235 { q2, new FieldMaskingSpanQuery(q1, "last")}, -1, false );
236 check(q, new int[] { 0, 2 });
237 q = new SpanNearQuery(new SpanQuery[]
238 { new FieldMaskingSpanQuery(q1, "last"), q2}, -1, false );
239 check(q, new int[] { 0, 2 });
243 public void testSimple2() throws Exception {
244 SpanQuery q1 = new SpanTermQuery(new Term("gender", "female"));
245 SpanQuery q2 = new SpanTermQuery(new Term("last", "smith"));
246 SpanQuery q = new SpanNearQuery(new SpanQuery[]
247 { q1, new FieldMaskingSpanQuery(q2, "gender")}, -1, false );
248 check(q, new int[] { 2, 4 });
249 q = new SpanNearQuery(new SpanQuery[]
250 { new FieldMaskingSpanQuery(q1, "id"),
251 new FieldMaskingSpanQuery(q2, "id") }, -1, false );
252 check(q, new int[] { 2, 4 });
255 public void testSpans0() throws Exception {
256 SpanQuery q1 = new SpanTermQuery(new Term("gender", "female"));
257 SpanQuery q2 = new SpanTermQuery(new Term("first", "james"));
258 SpanQuery q = new SpanOrQuery(new SpanQuery[]
259 { q1, new FieldMaskingSpanQuery(q2, "gender")});
260 check(q, new int[] { 0, 1, 2, 3, 4 });
262 Spans span = q.getSpans(searcher.getIndexReader());
264 assertEquals(true, span.next());
265 assertEquals(s(0,0,1), s(span));
267 assertEquals(true, span.next());
268 assertEquals(s(1,0,1), s(span));
270 assertEquals(true, span.next());
271 assertEquals(s(1,1,2), s(span));
273 assertEquals(true, span.next());
274 assertEquals(s(2,0,1), s(span));
276 assertEquals(true, span.next());
277 assertEquals(s(2,1,2), s(span));
279 assertEquals(true, span.next());
280 assertEquals(s(2,2,3), s(span));
282 assertEquals(true, span.next());
283 assertEquals(s(3,0,1), s(span));
285 assertEquals(true, span.next());
286 assertEquals(s(4,0,1), s(span));
288 assertEquals(true, span.next());
289 assertEquals(s(4,1,2), s(span));
291 assertEquals(false, span.next());
294 public void testSpans1() throws Exception {
295 SpanQuery q1 = new SpanTermQuery(new Term("first", "sally"));
296 SpanQuery q2 = new SpanTermQuery(new Term("first", "james"));
297 SpanQuery qA = new SpanOrQuery(new SpanQuery[] { q1, q2 });
298 SpanQuery qB = new FieldMaskingSpanQuery(qA, "id");
300 check(qA, new int[] { 0, 1, 2, 4 });
301 check(qB, new int[] { 0, 1, 2, 4 });
303 Spans spanA = qA.getSpans(searcher.getIndexReader());
304 Spans spanB = qB.getSpans(searcher.getIndexReader());
306 while (spanA.next()) {
307 assertTrue("spanB not still going", spanB.next());
308 assertEquals("spanA not equal spanB", s(spanA), s(spanB));
310 assertTrue("spanB still going even tough spanA is done", !(spanB.next()));
314 public void testSpans2() throws Exception {
315 SpanQuery qA1 = new SpanTermQuery(new Term("gender", "female"));
316 SpanQuery qA2 = new SpanTermQuery(new Term("first", "james"));
317 SpanQuery qA = new SpanOrQuery(new SpanQuery[]
318 { qA1, new FieldMaskingSpanQuery(qA2, "gender")});
319 SpanQuery qB = new SpanTermQuery(new Term("last", "jones"));
320 SpanQuery q = new SpanNearQuery(new SpanQuery[]
321 { new FieldMaskingSpanQuery(qA, "id"),
322 new FieldMaskingSpanQuery(qB, "id") }, -1, false );
323 check(q, new int[] { 0, 1, 2, 3 });
325 Spans span = q.getSpans(searcher.getIndexReader());
327 assertEquals(true, span.next());
328 assertEquals(s(0,0,1), s(span));
330 assertEquals(true, span.next());
331 assertEquals(s(1,1,2), s(span));
333 assertEquals(true, span.next());
334 assertEquals(s(2,0,1), s(span));
336 assertEquals(true, span.next());
337 assertEquals(s(2,2,3), s(span));
339 assertEquals(true, span.next());
340 assertEquals(s(3,0,1), s(span));
342 assertEquals(false, span.next());
345 public String s(Spans span) {
346 return s(span.doc(), span.start(), span.end());
348 public String s(int doc, int start, int end) {
349 return "s(" + doc + "," + start + "," + end +")";