← Back to branch summary

~slub.team/goobi-indexserver/3.x

« back to all changes in this revision

Viewing changes to lucene/backwards/src/test/org/apache/lucene/queryParser/TestMultiFieldQueryParser.java

  • Committer: Sebastian Meyer
  • Date: 2012-08-03 09:12:40 UTC
  • Revision ID: sebastian.meyer@slub-dresden.de-20120803091240-x6861b0vabq1xror
https://launchpad.net/bugs/985487
Remove Lucene and Solr source code and add patches instead
Fix Bug #985487: Auto-suggestion for the search interface

Show diffs side-by-side

added added

removed removed

Lines of Context:
lucene/backwards/src/test/org/apache/lucene/queryParser/TestMultiFieldQueryParser.java
1
 
package org.apache.lucene.queryParser;
2
 
 
3
 
/**
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
10
 
 *
11
 
 *     http://www.apache.org/licenses/LICENSE-2.0
12
 
 *
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.
18
 
 */
19
 
 
20
 
import java.io.IOException;
21
 
import java.io.Reader;
22
 
import java.util.HashMap;
23
 
import java.util.Map;
24
 
 
25
 
import org.apache.lucene.analysis.Analyzer;
26
 
import org.apache.lucene.analysis.MockAnalyzer;
27
 
import org.apache.lucene.analysis.TokenStream;
28
 
import org.apache.lucene.analysis.standard.StandardAnalyzer;
29
 
import org.apache.lucene.document.Document;
30
 
import org.apache.lucene.document.Field;
31
 
import org.apache.lucene.index.IndexWriter;
32
 
import org.apache.lucene.search.BooleanClause;
33
 
import org.apache.lucene.search.IndexSearcher;
34
 
import org.apache.lucene.search.Query;
35
 
import org.apache.lucene.search.ScoreDoc;
36
 
import org.apache.lucene.search.BooleanClause.Occur;
37
 
import org.apache.lucene.store.Directory;
38
 
import org.apache.lucene.util.LuceneTestCase;
39
 
 
40
 
/**
41
 
 * Tests QueryParser.
42
 
 */
43
 
public class TestMultiFieldQueryParser extends LuceneTestCase {
44
 
 
45
 
  /** test stop words parsing for both the non static form, and for the 
46
 
   * corresponding static form (qtxt, fields[]). */
47
 
  public void testStopwordsParsing() throws Exception {
48
 
    assertStopQueryEquals("one", "b:one t:one");  
49
 
    assertStopQueryEquals("one stop", "b:one t:one");  
50
 
    assertStopQueryEquals("one (stop)", "b:one t:one");  
51
 
    assertStopQueryEquals("one ((stop))", "b:one t:one");  
52
 
    assertStopQueryEquals("stop", "");  
53
 
    assertStopQueryEquals("(stop)", "");  
54
 
    assertStopQueryEquals("((stop))", "");  
55
 
  }
56
 
 
57
 
  // verify parsing of query using a stopping analyzer  
58
 
  private void assertStopQueryEquals (String qtxt, String expectedRes) throws Exception {
59
 
    String[] fields = {"b", "t"};
60
 
    Occur occur[] = {Occur.SHOULD, Occur.SHOULD};
61
 
    TestQueryParser.QPTestAnalyzer a = new TestQueryParser.QPTestAnalyzer();
62
 
    MultiFieldQueryParser mfqp = new MultiFieldQueryParser(TEST_VERSION_CURRENT, fields, a);
63
 
    
64
 
    Query q = mfqp.parse(qtxt);
65
 
    assertEquals(expectedRes, q.toString());
66
 
    
67
 
    q = MultiFieldQueryParser.parse(TEST_VERSION_CURRENT, qtxt, fields, occur, a);
68
 
    assertEquals(expectedRes, q.toString());
69
 
  }
70
 
  
71
 
  public void testSimple() throws Exception {
72
 
    String[] fields = {"b", "t"};
73
 
    MultiFieldQueryParser mfqp = new MultiFieldQueryParser(TEST_VERSION_CURRENT, fields, new MockAnalyzer(random));
74
 
    
75
 
    Query q = mfqp.parse("one");
76
 
    assertEquals("b:one t:one", q.toString());
77
 
    
78
 
    q = mfqp.parse("one two");
79
 
    assertEquals("(b:one t:one) (b:two t:two)", q.toString());
80
 
    
81
 
    q = mfqp.parse("+one +two");
82
 
    assertEquals("+(b:one t:one) +(b:two t:two)", q.toString());
83
 
 
84
 
    q = mfqp.parse("+one -two -three");
85
 
    assertEquals("+(b:one t:one) -(b:two t:two) -(b:three t:three)", q.toString());
86
 
    
87
 
    q = mfqp.parse("one^2 two");
88
 
    assertEquals("((b:one t:one)^2.0) (b:two t:two)", q.toString());
89
 
 
90
 
    q = mfqp.parse("one~ two");
91
 
    assertEquals("(b:one~0.5 t:one~0.5) (b:two t:two)", q.toString());
92
 
 
93
 
    q = mfqp.parse("one~0.8 two^2");
94
 
    assertEquals("(b:one~0.8 t:one~0.8) ((b:two t:two)^2.0)", q.toString());
95
 
 
96
 
    q = mfqp.parse("one* two*");
97
 
    assertEquals("(b:one* t:one*) (b:two* t:two*)", q.toString());
98
 
 
99
 
    q = mfqp.parse("[a TO c] two");
100
 
    assertEquals("(b:[a TO c] t:[a TO c]) (b:two t:two)", q.toString());
101
 
 
102
 
    q = mfqp.parse("w?ldcard");
103
 
    assertEquals("b:w?ldcard t:w?ldcard", q.toString());
104
 
 
105
 
    q = mfqp.parse("\"foo bar\"");
106
 
    assertEquals("b:\"foo bar\" t:\"foo bar\"", q.toString());
107
 
 
108
 
    q = mfqp.parse("\"aa bb cc\" \"dd ee\"");
109
 
    assertEquals("(b:\"aa bb cc\" t:\"aa bb cc\") (b:\"dd ee\" t:\"dd ee\")", q.toString());
110
 
 
111
 
    q = mfqp.parse("\"foo bar\"~4");
112
 
    assertEquals("b:\"foo bar\"~4 t:\"foo bar\"~4", q.toString());
113
 
 
114
 
    // LUCENE-1213: MultiFieldQueryParser was ignoring slop when phrase had a field.
115
 
    q = mfqp.parse("b:\"foo bar\"~4"); 
116
 
    assertEquals("b:\"foo bar\"~4", q.toString());
117
 
 
118
 
    // make sure that terms which have a field are not touched:
119
 
    q = mfqp.parse("one f:two");
120
 
    assertEquals("(b:one t:one) f:two", q.toString());
121
 
 
122
 
    // AND mode:
123
 
    mfqp.setDefaultOperator(QueryParser.AND_OPERATOR);
124
 
    q = mfqp.parse("one two");
125
 
    assertEquals("+(b:one t:one) +(b:two t:two)", q.toString());
126
 
    q = mfqp.parse("\"aa bb cc\" \"dd ee\"");
127
 
    assertEquals("+(b:\"aa bb cc\" t:\"aa bb cc\") +(b:\"dd ee\" t:\"dd ee\")", q.toString());
128
 
 
129
 
  }
130
 
  
131
 
  public void testBoostsSimple() throws Exception {
132
 
      Map<String,Float> boosts = new HashMap<String,Float>();
133
 
      boosts.put("b", Float.valueOf(5));
134
 
      boosts.put("t", Float.valueOf(10));
135
 
      String[] fields = {"b", "t"};
136
 
      MultiFieldQueryParser mfqp = new MultiFieldQueryParser(TEST_VERSION_CURRENT, fields, new MockAnalyzer(random), boosts);
137
 
      
138
 
      
139
 
      //Check for simple
140
 
      Query q = mfqp.parse("one");
141
 
      assertEquals("b:one^5.0 t:one^10.0", q.toString());
142
 
      
143
 
      //Check for AND
144
 
      q = mfqp.parse("one AND two");
145
 
      assertEquals("+(b:one^5.0 t:one^10.0) +(b:two^5.0 t:two^10.0)", q.toString());
146
 
      
147
 
      //Check for OR
148
 
      q = mfqp.parse("one OR two");
149
 
      assertEquals("(b:one^5.0 t:one^10.0) (b:two^5.0 t:two^10.0)", q.toString());
150
 
      
151
 
      //Check for AND and a field
152
 
      q = mfqp.parse("one AND two AND foo:test");
153
 
      assertEquals("+(b:one^5.0 t:one^10.0) +(b:two^5.0 t:two^10.0) +foo:test", q.toString());
154
 
      
155
 
      q = mfqp.parse("one^3 AND two^4");
156
 
      assertEquals("+((b:one^5.0 t:one^10.0)^3.0) +((b:two^5.0 t:two^10.0)^4.0)", q.toString());
157
 
  }
158
 
 
159
 
  public void testStaticMethod1() throws ParseException {
160
 
    String[] fields = {"b", "t"};
161
 
    String[] queries = {"one", "two"};
162
 
    Query q = MultiFieldQueryParser.parse(TEST_VERSION_CURRENT, queries, fields, new MockAnalyzer(random));
163
 
    assertEquals("b:one t:two", q.toString());
164
 
 
165
 
    String[] queries2 = {"+one", "+two"};
166
 
    q = MultiFieldQueryParser.parse(TEST_VERSION_CURRENT, queries2, fields, new MockAnalyzer(random));
167
 
    assertEquals("(+b:one) (+t:two)", q.toString());
168
 
 
169
 
    String[] queries3 = {"one", "+two"};
170
 
    q = MultiFieldQueryParser.parse(TEST_VERSION_CURRENT, queries3, fields, new MockAnalyzer(random));
171
 
    assertEquals("b:one (+t:two)", q.toString());
172
 
 
173
 
    String[] queries4 = {"one +more", "+two"};
174
 
    q = MultiFieldQueryParser.parse(TEST_VERSION_CURRENT, queries4, fields, new MockAnalyzer(random));
175
 
    assertEquals("(b:one +b:more) (+t:two)", q.toString());
176
 
 
177
 
    String[] queries5 = {"blah"};
178
 
    try {
179
 
      q = MultiFieldQueryParser.parse(TEST_VERSION_CURRENT, queries5, fields, new MockAnalyzer(random));
180
 
      fail();
181
 
    } catch(IllegalArgumentException e) {
182
 
      // expected exception, array length differs
183
 
    }
184
 
    
185
 
    // check also with stop words for this static form (qtxts[], fields[]).
186
 
    TestQueryParser.QPTestAnalyzer stopA = new TestQueryParser.QPTestAnalyzer();
187
 
    
188
 
    String[] queries6 = {"((+stop))", "+((stop))"};
189
 
    q = MultiFieldQueryParser.parse(TEST_VERSION_CURRENT, queries6, fields, stopA);
190
 
    assertEquals("", q.toString());
191
 
    
192
 
    String[] queries7 = {"one ((+stop)) +more", "+((stop)) +two"};
193
 
    q = MultiFieldQueryParser.parse(TEST_VERSION_CURRENT, queries7, fields, stopA);
194
 
    assertEquals("(b:one +b:more) (+t:two)", q.toString());
195
 
 
196
 
  }
197
 
 
198
 
  public void testStaticMethod2() throws ParseException {
199
 
    String[] fields = {"b", "t"};
200
 
    BooleanClause.Occur[] flags = {BooleanClause.Occur.MUST, BooleanClause.Occur.MUST_NOT};
201
 
    Query q = MultiFieldQueryParser.parse(TEST_VERSION_CURRENT, "one", fields, flags, new MockAnalyzer(random));
202
 
    assertEquals("+b:one -t:one", q.toString());
203
 
 
204
 
    q = MultiFieldQueryParser.parse(TEST_VERSION_CURRENT, "one two", fields, flags, new MockAnalyzer(random));
205
 
    assertEquals("+(b:one b:two) -(t:one t:two)", q.toString());
206
 
 
207
 
    try {
208
 
      BooleanClause.Occur[] flags2 = {BooleanClause.Occur.MUST};
209
 
      q = MultiFieldQueryParser.parse(TEST_VERSION_CURRENT, "blah", fields, flags2, new MockAnalyzer(random));
210
 
      fail();
211
 
    } catch(IllegalArgumentException e) {
212
 
      // expected exception, array length differs
213
 
    }
214
 
  }
215
 
 
216
 
  public void testStaticMethod2Old() throws ParseException {
217
 
    String[] fields = {"b", "t"};
218
 
    //int[] flags = {MultiFieldQueryParser.REQUIRED_FIELD, MultiFieldQueryParser.PROHIBITED_FIELD};
219
 
      BooleanClause.Occur[] flags = {BooleanClause.Occur.MUST, BooleanClause.Occur.MUST_NOT};
220
 
 
221
 
    Query q = MultiFieldQueryParser.parse(TEST_VERSION_CURRENT, "one", fields, flags, new MockAnalyzer(random));//, fields, flags, new MockAnalyzer(random));
222
 
    assertEquals("+b:one -t:one", q.toString());
223
 
 
224
 
    q = MultiFieldQueryParser.parse(TEST_VERSION_CURRENT, "one two", fields, flags, new MockAnalyzer(random));
225
 
    assertEquals("+(b:one b:two) -(t:one t:two)", q.toString());
226
 
 
227
 
    try {
228
 
      BooleanClause.Occur[] flags2 = {BooleanClause.Occur.MUST};
229
 
      q = MultiFieldQueryParser.parse(TEST_VERSION_CURRENT, "blah", fields, flags2, new MockAnalyzer(random));
230
 
      fail();
231
 
    } catch(IllegalArgumentException e) {
232
 
      // expected exception, array length differs
233
 
    }
234
 
  }
235
 
 
236
 
  public void testStaticMethod3() throws ParseException {
237
 
    String[] queries = {"one", "two", "three"};
238
 
    String[] fields = {"f1", "f2", "f3"};
239
 
    BooleanClause.Occur[] flags = {BooleanClause.Occur.MUST,
240
 
        BooleanClause.Occur.MUST_NOT, BooleanClause.Occur.SHOULD};
241
 
    Query q = MultiFieldQueryParser.parse(TEST_VERSION_CURRENT, queries, fields, flags, new MockAnalyzer(random));
242
 
    assertEquals("+f1:one -f2:two f3:three", q.toString());
243
 
 
244
 
    try {
245
 
      BooleanClause.Occur[] flags2 = {BooleanClause.Occur.MUST};
246
 
      q = MultiFieldQueryParser.parse(TEST_VERSION_CURRENT, queries, fields, flags2, new MockAnalyzer(random));
247
 
      fail();
248
 
    } catch(IllegalArgumentException e) {
249
 
      // expected exception, array length differs
250
 
    }
251
 
  }
252
 
 
253
 
  public void testStaticMethod3Old() throws ParseException {
254
 
    String[] queries = {"one", "two"};
255
 
    String[] fields = {"b", "t"};
256
 
      BooleanClause.Occur[] flags = {BooleanClause.Occur.MUST, BooleanClause.Occur.MUST_NOT};
257
 
    Query q = MultiFieldQueryParser.parse(TEST_VERSION_CURRENT, queries, fields, flags, new MockAnalyzer(random));
258
 
    assertEquals("+b:one -t:two", q.toString());
259
 
 
260
 
    try {
261
 
      BooleanClause.Occur[] flags2 = {BooleanClause.Occur.MUST};
262
 
      q = MultiFieldQueryParser.parse(TEST_VERSION_CURRENT, queries, fields, flags2, new MockAnalyzer(random));
263
 
      fail();
264
 
    } catch(IllegalArgumentException e) {
265
 
      // expected exception, array length differs
266
 
    }
267
 
  }
268
 
 
269
 
  public void testAnalyzerReturningNull() throws ParseException {
270
 
    String[] fields = new String[] { "f1", "f2", "f3" };
271
 
    MultiFieldQueryParser parser = new MultiFieldQueryParser(TEST_VERSION_CURRENT, fields, new AnalyzerReturningNull());
272
 
    Query q = parser.parse("bla AND blo");
273
 
    assertEquals("+(f2:bla f3:bla) +(f2:blo f3:blo)", q.toString());
274
 
    // the following queries are not affected as their terms are not analyzed anyway:
275
 
    q = parser.parse("bla*");
276
 
    assertEquals("f1:bla* f2:bla* f3:bla*", q.toString());
277
 
    q = parser.parse("bla~");
278
 
    assertEquals("f1:bla~0.5 f2:bla~0.5 f3:bla~0.5", q.toString());
279
 
    q = parser.parse("[a TO c]");
280
 
    assertEquals("f1:[a TO c] f2:[a TO c] f3:[a TO c]", q.toString());
281
 
  }
282
 
 
283
 
  public void testStopWordSearching() throws Exception {
284
 
    Analyzer analyzer = new MockAnalyzer(random);
285
 
    Directory ramDir = newDirectory();
286
 
    IndexWriter iw =  new IndexWriter(ramDir, newIndexWriterConfig(TEST_VERSION_CURRENT, analyzer));
287
 
    Document doc = new Document();
288
 
    doc.add(newField("body", "blah the footest blah", Field.Store.NO, Field.Index.ANALYZED));
289
 
    iw.addDocument(doc);
290
 
    iw.close();
291
 
    
292
 
    MultiFieldQueryParser mfqp = 
293
 
      new MultiFieldQueryParser(TEST_VERSION_CURRENT, new String[] {"body"}, analyzer);
294
 
    mfqp.setDefaultOperator(QueryParser.Operator.AND);
295
 
    Query q = mfqp.parse("the footest");
296
 
    IndexSearcher is = new IndexSearcher(ramDir, true);
297
 
    ScoreDoc[] hits = is.search(q, null, 1000).scoreDocs;
298
 
    assertEquals(1, hits.length);
299
 
    is.close();
300
 
    ramDir.close();
301
 
  }
302
 
  
303
 
  /**
304
 
   * Return empty tokens for field "f1".
305
 
   */
306
 
  private static class AnalyzerReturningNull extends Analyzer {
307
 
    MockAnalyzer stdAnalyzer = new MockAnalyzer(random);
308
 
 
309
 
    public AnalyzerReturningNull() {
310
 
    }
311
 
 
312
 
    @Override
313
 
    public TokenStream tokenStream(String fieldName, Reader reader) {
314
 
      if ("f1".equals(fieldName)) {
315
 
        return new EmptyTokenStream();
316
 
      } else {
317
 
        return stdAnalyzer.tokenStream(fieldName, reader);
318
 
      }
319
 
    }
320
 
 
321
 
    private static class EmptyTokenStream extends TokenStream {
322
 
      @Override
323
 
      public boolean incrementToken() throws IOException {
324
 
        return false;
325
 
      }
326
 
    }
327
 
  }
328
 
 
329
 
}