1 package org.apache.lucene.index;
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 org.apache.lucene.util.Constants;
22 import java.io.IOException;
23 import java.util.ArrayList;
24 import java.util.List;
26 import java.util.HashMap;
28 /** This {@link MergePolicy} is used for upgrading all existing segments of
29 * an index when calling {@link IndexWriter#optimize()}.
30 * All other methods delegate to the base {@code MergePolicy} given to the constructor.
31 * This allows for an as-cheap-as possible upgrade of an older index by only upgrading segments that
32 * are created by previous Lucene versions. Optimize does no longer really optimize
33 * it is just used to "optimize" older segment versions away.
34 * <p>In general one would use {@link IndexUpgrader}, but for a fully customizeable upgrade,
35 * you can use this like any other {@code MergePolicy} and call {@link IndexWriter#optimize()}:
36 * <pre class="prettyprint lang-java">
37 * IndexWriterConfig iwc = new IndexWriterConfig(Version.LUCENE_XX, new KeywordAnalyzer());
38 * iwc.setMergePolicy(new UpgradeIndexMergePolicy(iwc.getMergePolicy()));
39 * IndexWriter w = new IndexWriter(dir, iwc);
43 * <p><b>Warning:</b> This merge policy may reorder documents if the index was partially
44 * upgraded before calling optimize (e.g., documents were added). If your application relies
45 * on "monotonicity" of doc IDs (which means that the order in which the documents
46 * were added to the index is preserved), do a full optimize instead. Please note, the
47 * delegate {@code MergePolicy} may also reorder documents.
48 * @lucene.experimental
51 public class UpgradeIndexMergePolicy extends MergePolicy {
53 protected final MergePolicy base;
55 /** Wrap the given {@link MergePolicy} and intercept optimize requests to
56 * only upgrade segments written with previous Lucene versions. */
57 public UpgradeIndexMergePolicy(MergePolicy base) {
61 /** Returns if the given segment should be upgraded. The default implementation
62 * will return {@code !Constants.LUCENE_MAIN_VERSION.equals(si.getVersion())},
63 * so all segments created with a different version number than this Lucene version will
66 protected boolean shouldUpgradeSegment(SegmentInfo si) {
67 return !Constants.LUCENE_MAIN_VERSION.equals(si.getVersion());
71 public void setIndexWriter(IndexWriter writer) {
72 super.setIndexWriter(writer);
73 base.setIndexWriter(writer);
77 public MergeSpecification findMerges(SegmentInfos segmentInfos) throws CorruptIndexException, IOException {
78 return base.findMerges(segmentInfos);
82 public MergeSpecification findMergesForOptimize(SegmentInfos segmentInfos, int maxSegmentCount, Map<SegmentInfo,Boolean> segmentsToOptimize) throws CorruptIndexException, IOException {
83 // first find all old segments
84 final Map<SegmentInfo,Boolean> oldSegments = new HashMap<SegmentInfo,Boolean>();
85 for (final SegmentInfo si : segmentInfos) {
86 final Boolean v =segmentsToOptimize.get(si);
87 if (v != null && shouldUpgradeSegment(si)) {
88 oldSegments.put(si, v);
92 if (verbose()) message("findMergesForOptimize: segmentsToUpgrade=" + oldSegments);
94 if (oldSegments.isEmpty())
97 MergeSpecification spec = base.findMergesForOptimize(segmentInfos, maxSegmentCount, oldSegments);
100 // remove all segments that are in merge specification from oldSegments,
101 // the resulting set contains all segments that are left over
102 // and will be merged to one additional segment:
103 for (final OneMerge om : spec.merges) {
104 oldSegments.keySet().removeAll(om.segments);
108 if (!oldSegments.isEmpty()) {
110 message("findMergesForOptimize: " + base.getClass().getSimpleName() +
111 " does not want to merge all old segments, merge remaining ones into new segment: " + oldSegments);
112 final List<SegmentInfo> newInfos = new ArrayList<SegmentInfo>();
113 for (final SegmentInfo si : segmentInfos) {
114 if (oldSegments.containsKey(si)) {
118 // add the final merge
120 spec = new MergeSpecification();
122 spec.add(new OneMerge(newInfos));
129 public MergeSpecification findMergesToExpungeDeletes(SegmentInfos segmentInfos) throws CorruptIndexException, IOException {
130 return base.findMergesToExpungeDeletes(segmentInfos);
134 public boolean useCompoundFile(SegmentInfos segments, SegmentInfo newSegment) throws IOException {
135 return base.useCompoundFile(segments, newSegment);
139 public void close() {
144 public String toString() {
145 return "[" + getClass().getSimpleName() + "->" + base + "]";
148 private boolean verbose() {
149 IndexWriter w = writer.get();
150 return w != null && w.verbose();
153 private void message(String message) {
155 writer.get().message("UPGMP: " + message);