lucene-java-3.5.0/lucene/src/test/org/apache/lucene/index/TestParallelReader.java

   1 package org.apache.lucene.index;
   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.util.Arrays;
  22 import java.util.Collection;
  23 import java.util.Random;
  24
  25 import org.apache.lucene.analysis.MockAnalyzer;
  26 import org.apache.lucene.document.Document;
  27 import org.apache.lucene.document.Field;
  28 import org.apache.lucene.document.MapFieldSelector;
  29 import org.apache.lucene.search.BooleanQuery;
  30 import org.apache.lucene.search.IndexSearcher;
  31 import org.apache.lucene.search.Query;
  32 import org.apache.lucene.search.ScoreDoc;
  33 import org.apache.lucene.search.TermQuery;
  34 import org.apache.lucene.search.BooleanClause.Occur;
  35 import org.apache.lucene.store.Directory;
  36 import org.apache.lucene.util.LuceneTestCase;
  37
  38 public class TestParallelReader extends LuceneTestCase {
  39
  40   private IndexSearcher parallel;
  41   private IndexSearcher single;
  42   private Directory dir, dir1, dir2;
  43
  44   @Override
  45   public void setUp() throws Exception {
  46     super.setUp();
  47     single = single(random);
  48     parallel = parallel(random);
  49   }
  50
  51   @Override
  52   public void tearDown() throws Exception {
  53     single.getIndexReader().close();
  54     single.close();
  55     parallel.getIndexReader().close();
  56     parallel.close();
  57     dir.close();
  58     dir1.close();
  59     dir2.close();
  60     super.tearDown();
  61   }
  62
  63   public void testQueries() throws Exception {
  64     queryTest(new TermQuery(new Term("f1", "v1")));
  65     queryTest(new TermQuery(new Term("f1", "v2")));
  66     queryTest(new TermQuery(new Term("f2", "v1")));
  67     queryTest(new TermQuery(new Term("f2", "v2")));
  68     queryTest(new TermQuery(new Term("f3", "v1")));
  69     queryTest(new TermQuery(new Term("f3", "v2")));
  70     queryTest(new TermQuery(new Term("f4", "v1")));
  71     queryTest(new TermQuery(new Term("f4", "v2")));
  72
  73     BooleanQuery bq1 = new BooleanQuery();
  74     bq1.add(new TermQuery(new Term("f1", "v1")), Occur.MUST);
  75     bq1.add(new TermQuery(new Term("f4", "v1")), Occur.MUST);
  76     queryTest(bq1);
  77   }
  78
  79   public void testFieldNames() throws Exception {
  80     Directory dir1 = getDir1(random);
  81     Directory dir2 = getDir2(random);
  82     ParallelReader pr = new ParallelReader();
  83     pr.add(IndexReader.open(dir1, false));
  84     pr.add(IndexReader.open(dir2, false));
  85     Collection<String> fieldNames = pr.getFieldNames(IndexReader.FieldOption.ALL);
  86     assertEquals(4, fieldNames.size());
  87     assertTrue(fieldNames.contains("f1"));
  88     assertTrue(fieldNames.contains("f2"));
  89     assertTrue(fieldNames.contains("f3"));
  90     assertTrue(fieldNames.contains("f4"));
  91     pr.close();
  92     dir1.close();
  93     dir2.close();
  94   }
  95
  96   public void testDocument() throws IOException {
  97     Directory dir1 = getDir1(random);
  98     Directory dir2 = getDir2(random);
  99     ParallelReader pr = new ParallelReader();
 100     pr.add(IndexReader.open(dir1, false));
 101     pr.add(IndexReader.open(dir2, false));
 102
 103     Document doc11 = pr.document(0, new MapFieldSelector(new String[] {"f1"}));
 104     Document doc24 = pr.document(1, new MapFieldSelector(Arrays.asList(new String[] {"f4"})));
 105     Document doc223 = pr.document(1, new MapFieldSelector(new String[] {"f2", "f3"}));
 106
 107     assertEquals(1, doc11.getFields().size());
 108     assertEquals(1, doc24.getFields().size());
 109     assertEquals(2, doc223.getFields().size());
 110
 111     assertEquals("v1", doc11.get("f1"));
 112     assertEquals("v2", doc24.get("f4"));
 113     assertEquals("v2", doc223.get("f2"));
 114     assertEquals("v2", doc223.get("f3"));
 115     pr.close();
 116     dir1.close();
 117     dir2.close();
 118   }
 119
 120   public void testIncompatibleIndexes() throws IOException {
 121     // two documents:
 122     Directory dir1 = getDir1(random);
 123
 124     // one document only:
 125     Directory dir2 = newDirectory();
 126     IndexWriter w2 = new IndexWriter(dir2, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)));
 127     Document d3 = new Document();
 128     d3.add(newField("f3", "v1", Field.Store.YES, Field.Index.ANALYZED));
 129     w2.addDocument(d3);
 130     w2.close();
 131
 132     ParallelReader pr = new ParallelReader();
 133     pr.add(IndexReader.open(dir1, false));
 134     IndexReader ir = IndexReader.open(dir2, false);
 135     try {
 136       pr.add(ir);
 137       fail("didn't get exptected exception: indexes don't have same number of documents");
 138     } catch (IllegalArgumentException e) {
 139       // expected exception
 140     }
 141     pr.close();
 142     ir.close();
 143     dir1.close();
 144     dir2.close();
 145   }
 146
 147   public void testIsCurrent() throws IOException {
 148     Directory dir1 = getDir1(random);
 149     Directory dir2 = getDir2(random);
 150     ParallelReader pr = new ParallelReader();
 151     pr.add(IndexReader.open(dir1, false));
 152     pr.add(IndexReader.open(dir2, false));
 153
 154     assertTrue(pr.isCurrent());
 155     IndexReader modifier = IndexReader.open(dir1, false);
 156     modifier.setNorm(0, "f1", 100);
 157     modifier.close();
 158
 159     // one of the two IndexReaders which ParallelReader is using
 160     // is not current anymore
 161     assertFalse(pr.isCurrent());
 162
 163     modifier = IndexReader.open(dir2, false);
 164     modifier.setNorm(0, "f3", 100);
 165     modifier.close();
 166
 167     // now both are not current anymore
 168     assertFalse(pr.isCurrent());
 169     pr.close();
 170     dir1.close();
 171     dir2.close();
 172   }
 173
 174   public void testAllTermDocs() throws IOException {
 175     Directory dir1 = getDir1(random);
 176     Directory dir2 = getDir2(random);
 177     ParallelReader pr = new ParallelReader();
 178     pr.add(IndexReader.open(dir1, false));
 179     pr.add(IndexReader.open(dir2, false));
 180     int NUM_DOCS = 2;
 181     TermDocs td = pr.termDocs(null);
 182     for(int i=0;i<NUM_DOCS;i++) {
 183       assertTrue(td.next());
 184       assertEquals(i, td.doc());
 185       assertEquals(1, td.freq());
 186     }
 187     td.close();
 188     pr.close();
 189     dir1.close();
 190     dir2.close();
 191   }
 192
 193
 194   private void queryTest(Query query) throws IOException {
 195     ScoreDoc[] parallelHits = parallel.search(query, null, 1000).scoreDocs;
 196     ScoreDoc[] singleHits = single.search(query, null, 1000).scoreDocs;
 197     assertEquals(parallelHits.length, singleHits.length);
 198     for(int i = 0; i < parallelHits.length; i++) {
 199       assertEquals(parallelHits[i].score, singleHits[i].score, 0.001f);
 200       Document docParallel = parallel.doc(parallelHits[i].doc);
 201       Document docSingle = single.doc(singleHits[i].doc);
 202       assertEquals(docParallel.get("f1"), docSingle.get("f1"));
 203       assertEquals(docParallel.get("f2"), docSingle.get("f2"));
 204       assertEquals(docParallel.get("f3"), docSingle.get("f3"));
 205       assertEquals(docParallel.get("f4"), docSingle.get("f4"));
 206     }
 207   }
 208
 209   // Fields 1-4 indexed together:
 210   private IndexSearcher single(Random random) throws IOException {
 211     dir = newDirectory();
 212     IndexWriter w = new IndexWriter(dir, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)));
 213     Document d1 = new Document();
 214     d1.add(newField("f1", "v1", Field.Store.YES, Field.Index.ANALYZED));
 215     d1.add(newField("f2", "v1", Field.Store.YES, Field.Index.ANALYZED));
 216     d1.add(newField("f3", "v1", Field.Store.YES, Field.Index.ANALYZED));
 217     d1.add(newField("f4", "v1", Field.Store.YES, Field.Index.ANALYZED));
 218     w.addDocument(d1);
 219     Document d2 = new Document();
 220     d2.add(newField("f1", "v2", Field.Store.YES, Field.Index.ANALYZED));
 221     d2.add(newField("f2", "v2", Field.Store.YES, Field.Index.ANALYZED));
 222     d2.add(newField("f3", "v2", Field.Store.YES, Field.Index.ANALYZED));
 223     d2.add(newField("f4", "v2", Field.Store.YES, Field.Index.ANALYZED));
 224     w.addDocument(d2);
 225     w.close();
 226
 227     return new IndexSearcher(dir, false);
 228   }
 229
 230   // Fields 1 & 2 in one index, 3 & 4 in other, with ParallelReader:
 231   private IndexSearcher parallel(Random random) throws IOException {
 232     dir1 = getDir1(random);
 233     dir2 = getDir2(random);
 234     ParallelReader pr = new ParallelReader();
 235     pr.add(IndexReader.open(dir1, false));
 236     pr.add(IndexReader.open(dir2, false));
 237     return newSearcher(pr);
 238   }
 239
 240   private Directory getDir1(Random random) throws IOException {
 241     Directory dir1 = newDirectory();
 242     IndexWriter w1 = new IndexWriter(dir1, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)));
 243     Document d1 = new Document();
 244     d1.add(newField("f1", "v1", Field.Store.YES, Field.Index.ANALYZED));
 245     d1.add(newField("f2", "v1", Field.Store.YES, Field.Index.ANALYZED));
 246     w1.addDocument(d1);
 247     Document d2 = new Document();
 248     d2.add(newField("f1", "v2", Field.Store.YES, Field.Index.ANALYZED));
 249     d2.add(newField("f2", "v2", Field.Store.YES, Field.Index.ANALYZED));
 250     w1.addDocument(d2);
 251     w1.close();
 252     return dir1;
 253   }
 254
 255   private Directory getDir2(Random random) throws IOException {
 256     Directory dir2 = newDirectory();
 257     IndexWriter w2 = new IndexWriter(dir2, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)));
 258     Document d3 = new Document();
 259     d3.add(newField("f3", "v1", Field.Store.YES, Field.Index.ANALYZED));
 260     d3.add(newField("f4", "v1", Field.Store.YES, Field.Index.ANALYZED));
 261     w2.addDocument(d3);
 262     Document d4 = new Document();
 263     d4.add(newField("f3", "v2", Field.Store.YES, Field.Index.ANALYZED));
 264     d4.add(newField("f4", "v2", Field.Store.YES, Field.Index.ANALYZED));
 265     w2.addDocument(d4);
 266     w2.close();
 267     return dir2;
 268   }
 269
 270 }