← 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/index/TestIndexWriterOptimize.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/index/TestIndexWriterOptimize.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.analysis.MockAnalyzer;
23
 
import org.apache.lucene.document.Document;
24
 
import org.apache.lucene.document.Field;
25
 
import org.apache.lucene.document.Field.Index;
26
 
import org.apache.lucene.document.Field.Store;
27
 
import org.apache.lucene.document.Field.TermVector;
28
 
import org.apache.lucene.index.IndexWriterConfig.OpenMode;
29
 
import org.apache.lucene.store.Directory;
30
 
import org.apache.lucene.store.MockDirectoryWrapper;
31
 
import org.apache.lucene.util.LuceneTestCase;
32
 
import org.apache.lucene.util._TestUtil;
33
 
 
34
 
public class TestIndexWriterOptimize extends LuceneTestCase {
35
 
  public void testOptimizeMaxNumSegments() throws IOException {
36
 
 
37
 
    MockDirectoryWrapper dir = newDirectory();
38
 
 
39
 
    final Document doc = new Document();
40
 
    doc.add(newField("content", "aaa", Field.Store.NO, Field.Index.NOT_ANALYZED_NO_NORMS));
41
 
    final int incrMin = TEST_NIGHTLY ? 15 : 40;
42
 
    for(int numDocs=10;numDocs<500;numDocs += _TestUtil.nextInt(random, incrMin, 5*incrMin)) {
43
 
      LogDocMergePolicy ldmp = new LogDocMergePolicy();
44
 
      ldmp.setMinMergeDocs(1);
45
 
      ldmp.setMergeFactor(5);
46
 
      IndexWriter writer = new IndexWriter(dir, newIndexWriterConfig(
47
 
        TEST_VERSION_CURRENT, new MockAnalyzer(random))
48
 
        .setOpenMode(OpenMode.CREATE).setMaxBufferedDocs(2).setMergePolicy(
49
 
            ldmp));
50
 
      for(int j=0;j<numDocs;j++)
51
 
        writer.addDocument(doc);
52
 
      writer.close();
53
 
 
54
 
      SegmentInfos sis = new SegmentInfos();
55
 
      sis.read(dir);
56
 
      final int segCount = sis.size();
57
 
 
58
 
      ldmp = new LogDocMergePolicy();
59
 
      ldmp.setMergeFactor(5);
60
 
      writer = new IndexWriter(dir, newIndexWriterConfig( TEST_VERSION_CURRENT,
61
 
        new MockAnalyzer(random)).setMergePolicy(ldmp));
62
 
      writer.optimize(3);
63
 
      writer.close();
64
 
 
65
 
      sis = new SegmentInfos();
66
 
      sis.read(dir);
67
 
      final int optSegCount = sis.size();
68
 
 
69
 
      if (segCount < 3)
70
 
        assertEquals(segCount, optSegCount);
71
 
      else
72
 
        assertEquals(3, optSegCount);
73
 
    }
74
 
    dir.close();
75
 
  }
76
 
 
77
 
  public void testOptimizeMaxNumSegments2() throws IOException {
78
 
    MockDirectoryWrapper dir = newDirectory();
79
 
 
80
 
    final Document doc = new Document();
81
 
    doc.add(newField("content", "aaa", Field.Store.NO, Field.Index.NOT_ANALYZED_NO_NORMS));
82
 
 
83
 
    LogDocMergePolicy ldmp = new LogDocMergePolicy();
84
 
    ldmp.setMinMergeDocs(1);
85
 
    ldmp.setMergeFactor(4);
86
 
    IndexWriter writer = new IndexWriter(dir, newIndexWriterConfig(
87
 
      TEST_VERSION_CURRENT, new MockAnalyzer(random))
88
 
      .setMaxBufferedDocs(2).setMergePolicy(ldmp).setMergeScheduler(new ConcurrentMergeScheduler()));
89
 
 
90
 
    for(int iter=0;iter<10;iter++) {
91
 
      for(int i=0;i<19;i++)
92
 
        writer.addDocument(doc);
93
 
 
94
 
      writer.commit();
95
 
      writer.waitForMerges();
96
 
      writer.commit();
97
 
 
98
 
      SegmentInfos sis = new SegmentInfos();
99
 
      sis.read(dir);
100
 
 
101
 
      final int segCount = sis.size();
102
 
 
103
 
      writer.optimize(7);
104
 
      writer.commit();
105
 
      writer.waitForMerges();
106
 
 
107
 
      sis = new SegmentInfos();
108
 
      sis.read(dir);
109
 
      final int optSegCount = sis.size();
110
 
 
111
 
      if (segCount < 7)
112
 
        assertEquals(segCount, optSegCount);
113
 
      else
114
 
        assertEquals(7, optSegCount);
115
 
    }
116
 
    writer.close();
117
 
    dir.close();
118
 
  }
119
 
 
120
 
  /**
121
 
   * Make sure optimize doesn't use any more than 1X
122
 
   * starting index size as its temporary free space
123
 
   * required.
124
 
   */
125
 
  public void testOptimizeTempSpaceUsage() throws IOException {
126
 
 
127
 
    MockDirectoryWrapper dir = newDirectory();
128
 
    IndexWriter writer  = new IndexWriter(dir, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)).setMaxBufferedDocs(10).setMergePolicy(newLogMergePolicy()));
129
 
    if (VERBOSE) {
130
 
      System.out.println("TEST: config1=" + writer.getConfig());
131
 
    }
132
 
 
133
 
    for(int j=0;j<500;j++) {
134
 
      TestIndexWriter.addDocWithIndex(writer, j);
135
 
    }
136
 
    final int termIndexInterval = writer.getConfig().getTermIndexInterval();
137
 
    // force one extra segment w/ different doc store so
138
 
    // we see the doc stores get merged
139
 
    writer.commit();
140
 
    TestIndexWriter.addDocWithIndex(writer, 500);
141
 
    writer.close();
142
 
 
143
 
    if (VERBOSE) {
144
 
      System.out.println("TEST: start disk usage");
145
 
    }
146
 
    long startDiskUsage = 0;
147
 
    String[] files = dir.listAll();
148
 
    for(int i=0;i<files.length;i++) {
149
 
      startDiskUsage += dir.fileLength(files[i]);
150
 
      if (VERBOSE) {
151
 
        System.out.println(files[i] + ": " + dir.fileLength(files[i]));
152
 
      }
153
 
    }
154
 
 
155
 
    dir.resetMaxUsedSizeInBytes();
156
 
    dir.setTrackDiskUsage(true);
157
 
 
158
 
    // Import to use same term index interval else a
159
 
    // smaller one here could increase the disk usage and
160
 
    // cause a false failure:
161
 
    writer = new IndexWriter(dir, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)).setOpenMode(OpenMode.APPEND).setTermIndexInterval(termIndexInterval).setMergePolicy(newLogMergePolicy()));
162
 
    writer.setInfoStream(VERBOSE ? System.out : null);
163
 
    writer.optimize();
164
 
    writer.close();
165
 
    long maxDiskUsage = dir.getMaxUsedSizeInBytes();
166
 
    assertTrue("optimize used too much temporary space: starting usage was " + startDiskUsage + " bytes; max temp usage was " + maxDiskUsage + " but should have been " + (4*startDiskUsage) + " (= 4X starting usage)",
167
 
               maxDiskUsage <= 4*startDiskUsage);
168
 
    dir.close();
169
 
  }
170
 
  
171
 
  // Test calling optimize(false) whereby optimize is kicked
172
 
  // off but we don't wait for it to finish (but
173
 
  // writer.close()) does wait
174
 
  public void testBackgroundOptimize() throws IOException {
175
 
 
176
 
    Directory dir = newDirectory();
177
 
    for(int pass=0;pass<2;pass++) {
178
 
      IndexWriter writer = new IndexWriter(
179
 
          dir,
180
 
          newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)).
181
 
              setOpenMode(OpenMode.CREATE).
182
 
              setMaxBufferedDocs(2).
183
 
              setMergePolicy(newLogMergePolicy(51))
184
 
      );
185
 
      Document doc = new Document();
186
 
      doc.add(newField("field", "aaa", Store.NO, Index.NOT_ANALYZED));
187
 
      for(int i=0;i<100;i++)
188
 
        writer.addDocument(doc);
189
 
      writer.optimize(false);
190
 
 
191
 
      if (0 == pass) {
192
 
        writer.close();
193
 
        IndexReader reader = IndexReader.open(dir, true);
194
 
        assertTrue(reader.isOptimized());
195
 
        reader.close();
196
 
      } else {
197
 
        // Get another segment to flush so we can verify it is
198
 
        // NOT included in the optimization
199
 
        writer.addDocument(doc);
200
 
        writer.addDocument(doc);
201
 
        writer.close();
202
 
 
203
 
        IndexReader reader = IndexReader.open(dir, true);
204
 
        assertTrue(!reader.isOptimized());
205
 
        reader.close();
206
 
 
207
 
        SegmentInfos infos = new SegmentInfos();
208
 
        infos.read(dir);
209
 
        assertEquals(2, infos.size());
210
 
      }
211
 
    }
212
 
 
213
 
    dir.close();
214
 
  }
215
 
}