lucene-java-3.5.0/lucene/src/java/org/apache/lucene/index/UpgradeIndexMergePolicy.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 org.apache.lucene.util.Constants;
  21
  22 import java.io.IOException;
  23 import java.util.ArrayList;
  24 import java.util.List;
  25 import java.util.Map;
  26 import java.util.HashMap;
  27
  28 /** This {@link MergePolicy} is used for upgrading all existing segments of
  29   * an index when calling {@link IndexWriter#forceMerge(int)}.
  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. forceMerge does no longer really merge;
  33   * it is just used to &quot;forceMerge&quot; 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#forceMerge(int)}:
  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);
  40   *  w.forceMerge(1);
  41   *  w.close();
  42   * </pre>
  43   * <p><b>Warning:</b> This merge policy may reorder documents if the index was partially
  44   * upgraded before calling forceMerge (e.g., documents were added). If your application relies
  45   * on &quot;monotonicity&quot; of doc IDs (which means that the order in which the documents
  46   * were added to the index is preserved), do a forceMerge(1) instead. Please note, the
  47   * delegate {@code MergePolicy} may also reorder documents.
  48   * @lucene.experimental
  49   * @see IndexUpgrader
  50   */
  51 public class UpgradeIndexMergePolicy extends MergePolicy {
  52
  53   protected final MergePolicy base;
  54
  55   /** Wrap the given {@link MergePolicy} and intercept forceMerge requests to
  56    * only upgrade segments written with previous Lucene versions. */
  57   public UpgradeIndexMergePolicy(MergePolicy base) {
  58     this.base = base;
  59   }
  60
  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
  64    * get upgraded.
  65    */
  66   protected boolean shouldUpgradeSegment(SegmentInfo si) {
  67     return !Constants.LUCENE_MAIN_VERSION.equals(si.getVersion());
  68   }
  69
  70   @Override
  71   public void setIndexWriter(IndexWriter writer) {
  72     super.setIndexWriter(writer);
  73     base.setIndexWriter(writer);
  74   }
  75
  76   @Override
  77   public MergeSpecification findMerges(SegmentInfos segmentInfos) throws CorruptIndexException, IOException {
  78     return base.findMerges(segmentInfos);
  79   }
  80
  81   @Override
  82   public MergeSpecification findForcedMerges(SegmentInfos segmentInfos, int maxSegmentCount, Map<SegmentInfo,Boolean> segmentsToMerge) 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 = segmentsToMerge.get(si);
  87       if (v != null && shouldUpgradeSegment(si)) {
  88         oldSegments.put(si, v);
  89       }
  90     }
  91
  92     if (verbose()) message("findForcedMerges: segmentsToUpgrade=" + oldSegments);
  93
  94     if (oldSegments.isEmpty())
  95       return null;
  96
  97     MergeSpecification spec = base.findForcedMerges(segmentInfos, maxSegmentCount, oldSegments);
  98
  99     if (spec != null) {
 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);
 105       }
 106     }
 107
 108     if (!oldSegments.isEmpty()) {
 109       if (verbose())
 110         message("findForcedMerges: " +  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)) {
 115           newInfos.add(si);
 116         }
 117       }
 118       // add the final merge
 119       if (spec == null) {
 120         spec = new MergeSpecification();
 121       }
 122       spec.add(new OneMerge(newInfos));
 123     }
 124
 125     return spec;
 126   }
 127
 128   @Override
 129   public MergeSpecification findForcedDeletesMerges(SegmentInfos segmentInfos) throws CorruptIndexException, IOException {
 130     return base.findForcedDeletesMerges(segmentInfos);
 131   }
 132
 133   @Override
 134   public boolean useCompoundFile(SegmentInfos segments, SegmentInfo newSegment) throws IOException {
 135     return base.useCompoundFile(segments, newSegment);
 136   }
 137
 138   @Override
 139   public void close() {
 140     base.close();
 141   }
 142
 143   @Override
 144   public String toString() {
 145     return "[" + getClass().getSimpleName() + "->" + base + "]";
 146   }
 147
 148   private boolean verbose() {
 149     IndexWriter w = writer.get();
 150     return w != null && w.verbose();
 151   }
 152
 153   private void message(String message) {
 154     if (verbose())
 155       writer.get().message("UPGMP: " + message);
 156   }
 157
 158 }