lucene-java-3.4.0/lucene/backwards/src/test/org/apache/lucene/index/TestPerSegmentDeletes.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.ArrayList;
  22 import java.util.List;
  23 import java.util.Random;
  24 import java.util.Map;
  25
  26 import org.apache.lucene.analysis.MockAnalyzer;
  27 import org.apache.lucene.store.Directory;
  28 import org.apache.lucene.store.MockDirectoryWrapper;
  29 import org.apache.lucene.store.RAMDirectory;
  30 import org.apache.lucene.util.ArrayUtil;
  31 import org.apache.lucene.util.LuceneTestCase;
  32 import org.apache.lucene.util.Version;
  33
  34 public class TestPerSegmentDeletes extends LuceneTestCase {
  35   public void testDeletes1() throws Exception {
  36     //IndexWriter.debug2 = System.out;
  37     Directory dir = new MockDirectoryWrapper(new Random(), new RAMDirectory());
  38     IndexWriterConfig iwc = new IndexWriterConfig(Version.LUCENE_CURRENT,
  39         new MockAnalyzer(random));
  40     iwc.setMergeScheduler(new SerialMergeScheduler());
  41     iwc.setMaxBufferedDocs(5000);
  42     iwc.setRAMBufferSizeMB(100);
  43     RangeMergePolicy fsmp = new RangeMergePolicy(false);
  44     iwc.setMergePolicy(fsmp);
  45     IndexWriter writer = new IndexWriter(dir, iwc);
  46     writer.setInfoStream(VERBOSE ? System.out : null);
  47     for (int x = 0; x < 5; x++) {
  48       writer.addDocument(TestIndexWriterReader.createDocument(x, "1", 2));
  49       //System.out.println("numRamDocs(" + x + ")" + writer.numRamDocs());
  50     }
  51     //System.out.println("commit1");
  52     writer.commit();
  53     assertEquals(1, writer.segmentInfos.size());
  54     for (int x = 5; x < 10; x++) {
  55       writer.addDocument(TestIndexWriterReader.createDocument(x, "2", 2));
  56       //System.out.println("numRamDocs(" + x + ")" + writer.numRamDocs());
  57     }
  58     //System.out.println("commit2");
  59     writer.commit();
  60     assertEquals(2, writer.segmentInfos.size());
  61
  62     for (int x = 10; x < 15; x++) {
  63       writer.addDocument(TestIndexWriterReader.createDocument(x, "3", 2));
  64       //System.out.println("numRamDocs(" + x + ")" + writer.numRamDocs());
  65     }
  66
  67     writer.deleteDocuments(new Term("id", "1"));
  68
  69     writer.deleteDocuments(new Term("id", "11"));
  70
  71     // flushing without applying deletes means
  72     // there will still be deletes in the segment infos
  73     writer.flush(false, false);
  74     assertTrue(writer.bufferedDeletesStream.any());
  75
  76     // get reader flushes pending deletes
  77     // so there should not be anymore
  78     IndexReader r1 = writer.getReader();
  79     assertFalse(writer.bufferedDeletesStream.any());
  80     r1.close();
  81
  82     // delete id:2 from the first segment
  83     // merge segments 0 and 1
  84     // which should apply the delete id:2
  85     writer.deleteDocuments(new Term("id", "2"));
  86     writer.flush(false, false);
  87     fsmp.doMerge = true;
  88     fsmp.start = 0;
  89     fsmp.length = 2;
  90     writer.maybeMerge();
  91
  92     assertEquals(2, writer.segmentInfos.size());
  93
  94     // id:2 shouldn't exist anymore because
  95     // it's been applied in the merge and now it's gone
  96     IndexReader r2 = writer.getReader();
  97     int[] id2docs = toDocsArray(new Term("id", "2"), r2);
  98     assertTrue(id2docs == null);
  99     r2.close();
 100
 101     /**
 102     // added docs are in the ram buffer
 103     for (int x = 15; x < 20; x++) {
 104       writer.addDocument(TestIndexWriterReader.createDocument(x, "4", 2));
 105       System.out.println("numRamDocs(" + x + ")" + writer.numRamDocs());
 106     }
 107     assertTrue(writer.numRamDocs() > 0);
 108     // delete from the ram buffer
 109     writer.deleteDocuments(new Term("id", Integer.toString(13)));
 110
 111     Term id3 = new Term("id", Integer.toString(3));
 112
 113     // delete from the 1st segment
 114     writer.deleteDocuments(id3);
 115
 116     assertTrue(writer.numRamDocs() > 0);
 117
 118     //System.out
 119     //    .println("segdels1:" + writer.docWriter.deletesToString());
 120
 121     //assertTrue(writer.docWriter.segmentDeletes.size() > 0);
 122
 123     // we cause a merge to happen
 124     fsmp.doMerge = true;
 125     fsmp.start = 0;
 126     fsmp.length = 2;
 127     System.out.println("maybeMerge "+writer.segmentInfos);
 128
 129     SegmentInfo info0 = writer.segmentInfos.info(0);
 130     SegmentInfo info1 = writer.segmentInfos.info(1);
 131
 132     writer.maybeMerge();
 133     System.out.println("maybeMerge after "+writer.segmentInfos);
 134     // there should be docs in RAM
 135     assertTrue(writer.numRamDocs() > 0);
 136
 137     // assert we've merged the 1 and 2 segments
 138     // and still have a segment leftover == 2
 139     assertEquals(2, writer.segmentInfos.size());
 140     assertFalse(segThere(info0, writer.segmentInfos));
 141     assertFalse(segThere(info1, writer.segmentInfos));
 142
 143     //System.out.println("segdels2:" + writer.docWriter.deletesToString());
 144
 145     //assertTrue(writer.docWriter.segmentDeletes.size() > 0);
 146
 147     IndexReader r = writer.getReader();
 148     IndexReader r1 = r.getSequentialSubReaders()[0];
 149     printDelDocs(r1.getDeletedDocs());
 150     int[] docs = toDocsArray(id3, null, r);
 151     System.out.println("id3 docs:"+Arrays.toString(docs));
 152     // there shouldn't be any docs for id:3
 153     assertTrue(docs == null);
 154     r.close();
 155
 156     part2(writer, fsmp);
 157     **/
 158     // System.out.println("segdels2:"+writer.docWriter.segmentDeletes.toString());
 159     //System.out.println("close");
 160     writer.close();
 161     dir.close();
 162   }
 163
 164   /**
 165   static boolean hasPendingDeletes(SegmentInfos infos) {
 166     for (SegmentInfo info : infos) {
 167       if (info.deletes.any()) {
 168         return true;
 169       }
 170     }
 171     return false;
 172   }
 173   **/
 174   void part2(IndexWriter writer, RangeMergePolicy fsmp) throws Exception {
 175     for (int x = 20; x < 25; x++) {
 176       writer.addDocument(TestIndexWriterReader.createDocument(x, "5", 2));
 177       //System.out.println("numRamDocs(" + x + ")" + writer.numRamDocs());
 178     }
 179     writer.flush(false, false);
 180     for (int x = 25; x < 30; x++) {
 181       writer.addDocument(TestIndexWriterReader.createDocument(x, "5", 2));
 182       //System.out.println("numRamDocs(" + x + ")" + writer.numRamDocs());
 183     }
 184     writer.flush(false, false);
 185
 186     //System.out.println("infos3:"+writer.segmentInfos);
 187
 188     Term delterm = new Term("id", "8");
 189     writer.deleteDocuments(delterm);
 190     //System.out.println("segdels3:" + writer.docWriter.deletesToString());
 191
 192     fsmp.doMerge = true;
 193     fsmp.start = 1;
 194     fsmp.length = 2;
 195     writer.maybeMerge();
 196
 197     // deletes for info1, the newly created segment from the
 198     // merge should have no deletes because they were applied in
 199     // the merge
 200     //SegmentInfo info1 = writer.segmentInfos.info(1);
 201     //assertFalse(exists(info1, writer.docWriter.segmentDeletes));
 202
 203     //System.out.println("infos4:"+writer.segmentInfos);
 204     //System.out.println("segdels4:" + writer.docWriter.deletesToString());
 205   }
 206
 207   boolean segThere(SegmentInfo info, SegmentInfos infos) {
 208     for (SegmentInfo si : infos) {
 209       if (si.name.equals(info.name)) return true;
 210     }
 211     return false;
 212   }
 213
 214   public static int[] toDocsArray(Term term, IndexReader reader)
 215       throws IOException {
 216     TermDocs termDocs = reader.termDocs();
 217     termDocs.seek(term);
 218     return toArray(termDocs);
 219   }
 220
 221   public static int[] toArray(TermDocs termDocs) throws IOException {
 222     List<Integer> docs = new ArrayList<Integer>();
 223     while (termDocs.next()) {
 224       docs.add(termDocs.doc());
 225     }
 226     if (docs.size() == 0) {
 227       return null;
 228     } else {
 229       return ArrayUtil.toIntArray(docs);
 230     }
 231   }
 232
 233   public class RangeMergePolicy extends MergePolicy {
 234     boolean doMerge = false;
 235     int start;
 236     int length;
 237
 238     private final boolean useCompoundFile;
 239
 240     private RangeMergePolicy(boolean useCompoundFile) {
 241       this.useCompoundFile = useCompoundFile;
 242     }
 243
 244     @Override
 245     public void close() {}
 246
 247     @Override
 248     public MergeSpecification findMerges(SegmentInfos segmentInfos)
 249         throws CorruptIndexException, IOException {
 250       MergeSpecification ms = new MergeSpecification();
 251       if (doMerge) {
 252         OneMerge om = new OneMerge(segmentInfos.asList().subList(start, start + length));
 253         ms.add(om);
 254         doMerge = false;
 255         return ms;
 256       }
 257       return null;
 258     }
 259
 260     @Override
 261     public MergeSpecification findMergesForOptimize(SegmentInfos segmentInfos,
 262         int maxSegmentCount, Map<SegmentInfo,Boolean> segmentsToOptimize)
 263         throws CorruptIndexException, IOException {
 264       return null;
 265     }
 266
 267     @Override
 268     public MergeSpecification findMergesToExpungeDeletes(
 269         SegmentInfos segmentInfos) throws CorruptIndexException, IOException {
 270       return null;
 271     }
 272
 273     @Override
 274     public boolean useCompoundFile(SegmentInfos segments, SegmentInfo newSegment) {
 275       return useCompoundFile;
 276     }
 277   }
 278 }