関口宏司のLuceneブログ

doc.add( new Field( "body", bodyString, Store.COMPRESS, Index.ANALYZED ) );

doc.add( new Field( "body", bodyString, Store.NO, Index.ANALYZED ) );
doc.add( new Field( "body", CompressionTools.compressString(bodyString), Store.YES ) );

public class MergeSimulator {
  
  static final String CSV_FILE = "segments.csv";
  static final int MERGE_FACTOR = 3;
  static final int MAX_BUFFERED_DOCS = 3;
  static final int NUM_DOCS = 3000;

  public static void main( String[] args ) throws FileNotFoundException {
    Directory dir = new Directory( MERGE_FACTOR );
    PrintStream ps = new PrintStream( CSV_FILE );
    dir.logHeader( ps );
    Writer writer = new Writer( MAX_BUFFERED_DOCS, dir, ps );
    for( int i = 0; i < NUM_DOCS; i++ ){
      writer.add( new Doc() );
    }
    ps.close();
  }

  static class Doc {
  }

  static class Segment {
    private final int level;
    private final int numDocs;
    private boolean deleted;
    public void delete(){ deleted = true; }
    public boolean isDeleted(){ return deleted; }
    public Segment( int numDocs ){
      this( 0, numDocs );
    }
    public Segment( int level, int numDocs ){
      this.level = level;
      this.numDocs = numDocs;
    }
    public int getSize(){ return numDocs; }
    public int getLevel(){ return level; }
  }
  
  static class Directory {
    private final int mergeFactor;
    private List> segmentsList = new ArrayList>();
    public Directory( int mergeFactor ){
      this.mergeFactor = mergeFactor;
    }
    public List> getSegmentsList(){ return segmentsList; }
    public int getNumSegments(){
      int num = 0;
      for( List segments : segmentsList ){
        if( segments == null ) continue;
        for( Segment segment : segments ){
          num++;
        }
      }
      return num;
    }
    public int getSize(){
      int size = 0;
      for( List segments : segmentsList ){
        if( segments == null ) continue;
        for( Segment segment : segments ){
          size += segment.getSize();
        }
      }
      return size;
    }
    public void addSegment( Segment segment ){
      int level = segment.getLevel();
      if( segmentsList.size() <= level )
        segmentsList.add( new ArrayList() );
      List segments = segmentsList.get( level );
      segments.add( segment );
      if( needMerge( level ) )
        merge( level );
    }
    public void merge( int level ){
      List segmentsToBeMerged = segmentsList.get( level );
      int totalDocs = 0;
      for( Segment segment : segmentsToBeMerged ){
        totalDocs += segment.numDocs;
        segment.delete();
      }
      Segment mergedSegment = new Segment( level + 1, totalDocs );
      addSegment( mergedSegment );
    }
    public boolean needMerge( int level ){
      List segments = segmentsList.get( level );
      if( segments == null ) return false;
      return segments.size() >= mergeFactor;
    }
    public void deleteMergedSegments(){
      for( List segments : segmentsList ){
        if( segments == null ) continue;
        for( Iterator ite = segments.iterator(); ite.hasNext(); ){
          Segment segment = ite.next();
          if( segment.isDeleted() ){
            ite.remove();
          }
        }
      }
    }
    public void logHeader( PrintStream ps ){
      ps.println( "number of segments, total size" );
    }
    public void log( PrintStream ps ){
      ps.println( getNumSegments() + ", " + getSize() );
    }
  }
  
  static class Writer {
    final int maxBufferedDocs;
    final Directory dir;
    final PrintStream ps;
    int docs;
    public Writer( int maxBufferedDocs, Directory dir, PrintStream ps ){
      this.maxBufferedDocs = maxBufferedDocs;
      this.dir = dir;
      this.ps = ps;
      docs = 0;
    }
    public void add( Doc doc ){
      if( ++docs >= maxBufferedDocs ){
        Segment segment = new Segment( docs );
        dir.addSegment( segment );
        dir.log( ps );
        dir.deleteMergedSegments();
        docs = 0;
      }
      else{
        dir.log( ps );
      }
    }
  }
}