lucene-java-3.4.0/lucene/src/test/org/apache/lucene/index/TestSizeBoundedOptimize.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
  22 import org.apache.lucene.document.Document;
  23 import org.apache.lucene.store.Directory;
  24 import org.apache.lucene.store.RAMDirectory;
  25 import org.apache.lucene.util.LuceneTestCase;
  26
  27 public class TestSizeBoundedOptimize extends LuceneTestCase {
  28
  29   private void addDocs(IndexWriter writer, int numDocs) throws IOException {
  30     for (int i = 0; i < numDocs; i++) {
  31       Document doc = new Document();
  32       writer.addDocument(doc);
  33     }
  34     writer.commit();
  35   }
  36
  37   private static IndexWriterConfig newWriterConfig() throws IOException {
  38     IndexWriterConfig conf = newIndexWriterConfig(TEST_VERSION_CURRENT, null);
  39     conf.setMaxBufferedDocs(IndexWriterConfig.DISABLE_AUTO_FLUSH);
  40     conf.setRAMBufferSizeMB(IndexWriterConfig.DEFAULT_RAM_BUFFER_SIZE_MB);
  41     // prevent any merges by default.
  42     conf.setMergePolicy(NoMergePolicy.COMPOUND_FILES);
  43     return conf;
  44   }
  45
  46   public void testByteSizeLimit() throws Exception {
  47     // tests that the max merge size constraint is applied during optimize.
  48     Directory dir = new RAMDirectory();
  49
  50     // Prepare an index w/ several small segments and a large one.
  51     IndexWriterConfig conf = newWriterConfig();
  52     IndexWriter writer = new IndexWriter(dir, conf);
  53     final int numSegments = 15;
  54     for (int i = 0; i < numSegments; i++) {
  55       int numDocs = i == 7 ? 30 : 1;
  56       addDocs(writer, numDocs);
  57     }
  58     writer.close();
  59
  60     SegmentInfos sis = new SegmentInfos();
  61     sis.read(dir);
  62     double min = sis.info(0).sizeInBytes(true);
  63
  64     conf = newWriterConfig();
  65     LogByteSizeMergePolicy lmp = new LogByteSizeMergePolicy();
  66     lmp.setMaxMergeMBForOptimize((min + 1) / (1 << 20));
  67     conf.setMergePolicy(lmp);
  68
  69     writer = new IndexWriter(dir, conf);
  70     writer.optimize();
  71     writer.close();
  72
  73     // Should only be 3 segments in the index, because one of them exceeds the size limit
  74     sis = new SegmentInfos();
  75     sis.read(dir);
  76     assertEquals(3, sis.size());
  77   }
  78
  79   public void testNumDocsLimit() throws Exception {
  80     // tests that the max merge docs constraint is applied during optimize.
  81     Directory dir = new RAMDirectory();
  82
  83     // Prepare an index w/ several small segments and a large one.
  84     IndexWriterConfig conf = newWriterConfig();
  85     IndexWriter writer = new IndexWriter(dir, conf);
  86
  87     addDocs(writer, 3);
  88     addDocs(writer, 3);
  89     addDocs(writer, 5);
  90     addDocs(writer, 3);
  91     addDocs(writer, 3);
  92     addDocs(writer, 3);
  93     addDocs(writer, 3);
  94
  95     writer.close();
  96
  97     conf = newWriterConfig();
  98     LogMergePolicy lmp = new LogDocMergePolicy();
  99     lmp.setMaxMergeDocs(3);
 100     conf.setMergePolicy(lmp);
 101
 102     writer = new IndexWriter(dir, conf);
 103     writer.optimize();
 104     writer.close();
 105
 106     // Should only be 3 segments in the index, because one of them exceeds the size limit
 107     SegmentInfos sis = new SegmentInfos();
 108     sis.read(dir);
 109     assertEquals(3, sis.size());
 110   }
 111
 112   public void testLastSegmentTooLarge() throws Exception {
 113     Directory dir = new RAMDirectory();
 114
 115     IndexWriterConfig conf = newWriterConfig();
 116     IndexWriter writer = new IndexWriter(dir, conf);
 117
 118     addDocs(writer, 3);
 119     addDocs(writer, 3);
 120     addDocs(writer, 3);
 121     addDocs(writer, 5);
 122
 123     writer.close();
 124
 125     conf = newWriterConfig();
 126     LogMergePolicy lmp = new LogDocMergePolicy();
 127     lmp.setMaxMergeDocs(3);
 128     conf.setMergePolicy(lmp);
 129
 130     writer = new IndexWriter(dir, conf);
 131     writer.optimize();
 132     writer.close();
 133
 134     SegmentInfos sis = new SegmentInfos();
 135     sis.read(dir);
 136     assertEquals(2, sis.size());
 137   }
 138
 139   public void testFirstSegmentTooLarge() throws Exception {
 140     Directory dir = new RAMDirectory();
 141
 142     IndexWriterConfig conf = newWriterConfig();
 143     IndexWriter writer = new IndexWriter(dir, conf);
 144
 145     addDocs(writer, 5);
 146     addDocs(writer, 3);
 147     addDocs(writer, 3);
 148     addDocs(writer, 3);
 149
 150     writer.close();
 151
 152     conf = newWriterConfig();
 153     LogMergePolicy lmp = new LogDocMergePolicy();
 154     lmp.setMaxMergeDocs(3);
 155     conf.setMergePolicy(lmp);
 156
 157     writer = new IndexWriter(dir, conf);
 158     writer.optimize();
 159     writer.close();
 160
 161     SegmentInfos sis = new SegmentInfos();
 162     sis.read(dir);
 163     assertEquals(2, sis.size());
 164   }
 165
 166   public void testAllSegmentsSmall() throws Exception {
 167     Directory dir = new RAMDirectory();
 168
 169     IndexWriterConfig conf = newWriterConfig();
 170     IndexWriter writer = new IndexWriter(dir, conf);
 171
 172     addDocs(writer, 3);
 173     addDocs(writer, 3);
 174     addDocs(writer, 3);
 175     addDocs(writer, 3);
 176
 177     writer.close();
 178
 179     conf = newWriterConfig();
 180     LogMergePolicy lmp = new LogDocMergePolicy();
 181     lmp.setMaxMergeDocs(3);
 182     conf.setMergePolicy(lmp);
 183
 184     writer = new IndexWriter(dir, conf);
 185     writer.optimize();
 186     writer.close();
 187
 188     SegmentInfos sis = new SegmentInfos();
 189     sis.read(dir);
 190     assertEquals(1, sis.size());
 191   }
 192
 193   public void testAllSegmentsLarge() throws Exception {
 194     Directory dir = new RAMDirectory();
 195
 196     IndexWriterConfig conf = newWriterConfig();
 197     IndexWriter writer = new IndexWriter(dir, conf);
 198
 199     addDocs(writer, 3);
 200     addDocs(writer, 3);
 201     addDocs(writer, 3);
 202
 203     writer.close();
 204
 205     conf = newWriterConfig();
 206     LogMergePolicy lmp = new LogDocMergePolicy();
 207     lmp.setMaxMergeDocs(2);
 208     conf.setMergePolicy(lmp);
 209
 210     writer = new IndexWriter(dir, conf);
 211     writer.optimize();
 212     writer.close();
 213
 214     SegmentInfos sis = new SegmentInfos();
 215     sis.read(dir);
 216     assertEquals(3, sis.size());
 217   }
 218
 219   public void testOneLargeOneSmall() throws Exception {
 220     Directory dir = new RAMDirectory();
 221
 222     IndexWriterConfig conf = newWriterConfig();
 223     IndexWriter writer = new IndexWriter(dir, conf);
 224
 225     addDocs(writer, 3);
 226     addDocs(writer, 5);
 227     addDocs(writer, 3);
 228     addDocs(writer, 5);
 229
 230     writer.close();
 231
 232     conf = newWriterConfig();
 233     LogMergePolicy lmp = new LogDocMergePolicy();
 234     lmp.setMaxMergeDocs(3);
 235     conf.setMergePolicy(lmp);
 236
 237     writer = new IndexWriter(dir, conf);
 238     writer.optimize();
 239     writer.close();
 240
 241     SegmentInfos sis = new SegmentInfos();
 242     sis.read(dir);
 243     assertEquals(4, sis.size());
 244   }
 245
 246   public void testMergeFactor() throws Exception {
 247     Directory dir = new RAMDirectory();
 248
 249     IndexWriterConfig conf = newWriterConfig();
 250     IndexWriter writer = new IndexWriter(dir, conf);
 251
 252     addDocs(writer, 3);
 253     addDocs(writer, 3);
 254     addDocs(writer, 3);
 255     addDocs(writer, 3);
 256     addDocs(writer, 5);
 257     addDocs(writer, 3);
 258     addDocs(writer, 3);
 259
 260     writer.close();
 261
 262     conf = newWriterConfig();
 263     LogMergePolicy lmp = new LogDocMergePolicy();
 264     lmp.setMaxMergeDocs(3);
 265     lmp.setMergeFactor(2);
 266     conf.setMergePolicy(lmp);
 267
 268     writer = new IndexWriter(dir, conf);
 269     writer.optimize();
 270     writer.close();
 271
 272     // Should only be 4 segments in the index, because of the merge factor and
 273     // max merge docs settings.
 274     SegmentInfos sis = new SegmentInfos();
 275     sis.read(dir);
 276     assertEquals(4, sis.size());
 277   }
 278
 279   public void testSingleNonOptimizedSegment() throws Exception {
 280     Directory dir = new RAMDirectory();
 281
 282     IndexWriterConfig conf = newWriterConfig();
 283     IndexWriter writer = new IndexWriter(dir, conf);
 284
 285     addDocs(writer, 3);
 286     addDocs(writer, 5);
 287     addDocs(writer, 3);
 288
 289     writer.close();
 290
 291     // delete the last document, so that the last segment is optimized.
 292     IndexReader r = IndexReader.open(dir, false);
 293     r.deleteDocument(r.numDocs() - 1);
 294     r.close();
 295
 296     conf = newWriterConfig();
 297     LogMergePolicy lmp = new LogDocMergePolicy();
 298     lmp.setMaxMergeDocs(3);
 299     conf.setMergePolicy(lmp);
 300
 301     writer = new IndexWriter(dir, conf);
 302     writer.optimize();
 303     writer.close();
 304
 305     // Verify that the last segment does not have deletions.
 306     SegmentInfos sis = new SegmentInfos();
 307     sis.read(dir);
 308     assertEquals(3, sis.size());
 309     assertFalse(sis.info(2).hasDeletions());
 310   }
 311
 312   public void testSingleOptimizedSegment() throws Exception {
 313     Directory dir = new RAMDirectory();
 314
 315     IndexWriterConfig conf = newWriterConfig();
 316     IndexWriter writer = new IndexWriter(dir, conf);
 317
 318     addDocs(writer, 3);
 319
 320     writer.close();
 321
 322     conf = newWriterConfig();
 323     LogMergePolicy lmp = new LogDocMergePolicy();
 324     lmp.setMaxMergeDocs(3);
 325     conf.setMergePolicy(lmp);
 326
 327     writer = new IndexWriter(dir, conf);
 328     writer.optimize();
 329     writer.close();
 330
 331     // Verify that the last segment does not have deletions.
 332     SegmentInfos sis = new SegmentInfos();
 333     sis.read(dir);
 334     assertEquals(1, sis.size());
 335   }
 336
 337   public void testSingleNonOptimizedTooLargeSegment() throws Exception {
 338     Directory dir = new RAMDirectory();
 339
 340     IndexWriterConfig conf = newWriterConfig();
 341     IndexWriter writer = new IndexWriter(dir, conf);
 342
 343     addDocs(writer, 5);
 344
 345     writer.close();
 346
 347     // delete the last document
 348     IndexReader r = IndexReader.open(dir, false);
 349     r.deleteDocument(r.numDocs() - 1);
 350     r.close();
 351
 352     conf = newWriterConfig();
 353     LogMergePolicy lmp = new LogDocMergePolicy();
 354     lmp.setMaxMergeDocs(2);
 355     conf.setMergePolicy(lmp);
 356
 357     writer = new IndexWriter(dir, conf);
 358     writer.optimize();
 359     writer.close();
 360
 361     // Verify that the last segment does not have deletions.
 362     SegmentInfos sis = new SegmentInfos();
 363     sis.read(dir);
 364     assertEquals(1, sis.size());
 365     assertTrue(sis.info(0).hasDeletions());
 366   }
 367
 368 }