← Back to branch summary

~slub.team/goobi-indexserver/3.x

« back to all changes in this revision

Viewing changes to lucene/src/java/org/apache/lucene/index/TermVectorsTermsWriter.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/src/java/org/apache/lucene/index/TermVectorsTermsWriter.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.store.IndexOutput;
21
 
import org.apache.lucene.store.RAMOutputStream;
22
 
import org.apache.lucene.util.ArrayUtil;
23
 
import org.apache.lucene.util.IOUtils;
24
 
import org.apache.lucene.util.RamUsageEstimator;
25
 
 
26
 
import java.io.IOException;
27
 
import java.util.Collection;
28
 
 
29
 
import java.util.Map;
30
 
 
31
 
final class TermVectorsTermsWriter extends TermsHashConsumer {
32
 
 
33
 
  final DocumentsWriter docWriter;
34
 
  PerDoc[] docFreeList = new PerDoc[1];
35
 
  int freeCount;
36
 
  IndexOutput tvx;
37
 
  IndexOutput tvd;
38
 
  IndexOutput tvf;
39
 
  int lastDocID;
40
 
  boolean hasVectors;
41
 
 
42
 
  public TermVectorsTermsWriter(DocumentsWriter docWriter) {
43
 
    this.docWriter = docWriter;
44
 
  }
45
 
 
46
 
  @Override
47
 
  public TermsHashConsumerPerThread addThread(TermsHashPerThread termsHashPerThread) {
48
 
    return new TermVectorsTermsWriterPerThread(termsHashPerThread, this);
49
 
  }
50
 
 
51
 
  @Override
52
 
  synchronized void flush(Map<TermsHashConsumerPerThread,Collection<TermsHashConsumerPerField>> threadsAndFields, final SegmentWriteState state) throws IOException {
53
 
    if (tvx != null) {
54
 
      // At least one doc in this run had term vectors enabled
55
 
      fill(state.numDocs);
56
 
      IOUtils.close(tvx, tvf, tvd);
57
 
      tvx = tvd = tvf = null;
58
 
      assert state.segmentName != null;
59
 
      String idxName = IndexFileNames.segmentFileName(state.segmentName, IndexFileNames.VECTORS_INDEX_EXTENSION);
60
 
      if (4 + ((long) state.numDocs) * 16 != state.directory.fileLength(idxName)) {
61
 
        throw new RuntimeException("after flush: tvx size mismatch: " + state.numDocs + " docs vs " + state.directory.fileLength(idxName) + " length in bytes of " + idxName + " file exists?=" + state.directory.fileExists(idxName));
62
 
      }
63
 
 
64
 
      lastDocID = 0;
65
 
      state.hasVectors = hasVectors;
66
 
      hasVectors = false;
67
 
    }
68
 
 
69
 
    for (Map.Entry<TermsHashConsumerPerThread,Collection<TermsHashConsumerPerField>> entry : threadsAndFields.entrySet()) {
70
 
      for (final TermsHashConsumerPerField field : entry.getValue() ) {
71
 
        TermVectorsTermsWriterPerField perField = (TermVectorsTermsWriterPerField) field;
72
 
        perField.termsHashPerField.reset();
73
 
        perField.shrinkHash();
74
 
      }
75
 
 
76
 
      TermVectorsTermsWriterPerThread perThread = (TermVectorsTermsWriterPerThread) entry.getKey();
77
 
      perThread.termsHashPerThread.reset(true);
78
 
    }
79
 
  }
80
 
 
81
 
  int allocCount;
82
 
 
83
 
  synchronized PerDoc getPerDoc() {
84
 
    if (freeCount == 0) {
85
 
      allocCount++;
86
 
      if (allocCount > docFreeList.length) {
87
 
        // Grow our free list up front to make sure we have
88
 
        // enough space to recycle all outstanding PerDoc
89
 
        // instances
90
 
        assert allocCount == 1+docFreeList.length;
91
 
        docFreeList = new PerDoc[ArrayUtil.oversize(allocCount, RamUsageEstimator.NUM_BYTES_OBJECT_REF)];
92
 
      }
93
 
      return new PerDoc();
94
 
    } else {
95
 
      return docFreeList[--freeCount];
96
 
    }
97
 
  }
98
 
 
99
 
  /** Fills in no-term-vectors for all docs we haven't seen
100
 
   *  since the last doc that had term vectors. */
101
 
  void fill(int docID) throws IOException {
102
 
    if (lastDocID < docID) {
103
 
      final long tvfPosition = tvf.getFilePointer();
104
 
      while(lastDocID < docID) {
105
 
        tvx.writeLong(tvd.getFilePointer());
106
 
        tvd.writeVInt(0);
107
 
        tvx.writeLong(tvfPosition);
108
 
        lastDocID++;
109
 
      }
110
 
    }
111
 
  }
112
 
 
113
 
  synchronized void initTermVectorsWriter() throws IOException {        
114
 
    if (tvx == null) {
115
 
      boolean success = false;
116
 
      try {
117
 
        // If we hit an exception while init'ing the term
118
 
        // vector output files, we must abort this segment
119
 
        // because those files will be in an unknown
120
 
        // state:
121
 
        hasVectors = true;
122
 
        tvx = docWriter.directory.createOutput(IndexFileNames.segmentFileName(docWriter.getSegment(), IndexFileNames.VECTORS_INDEX_EXTENSION));
123
 
        tvd = docWriter.directory.createOutput(IndexFileNames.segmentFileName(docWriter.getSegment(), IndexFileNames.VECTORS_DOCUMENTS_EXTENSION));
124
 
        tvf = docWriter.directory.createOutput(IndexFileNames.segmentFileName(docWriter.getSegment(), IndexFileNames.VECTORS_FIELDS_EXTENSION));
125
 
        
126
 
        tvx.writeInt(TermVectorsReader.FORMAT_CURRENT);
127
 
        tvd.writeInt(TermVectorsReader.FORMAT_CURRENT);
128
 
        tvf.writeInt(TermVectorsReader.FORMAT_CURRENT);
129
 
        success = true;
130
 
      } finally {
131
 
        if (!success) {
132
 
          IOUtils.closeWhileHandlingException(tvx, tvd, tvf);
133
 
        }
134
 
      }
135
 
      lastDocID = 0;
136
 
    }
137
 
  }
138
 
 
139
 
  synchronized void finishDocument(PerDoc perDoc) throws IOException {
140
 
 
141
 
    assert docWriter.writer.testPoint("TermVectorsTermsWriter.finishDocument start");
142
 
 
143
 
    initTermVectorsWriter();
144
 
 
145
 
    fill(perDoc.docID);
146
 
 
147
 
    // Append term vectors to the real outputs:
148
 
    tvx.writeLong(tvd.getFilePointer());
149
 
    tvx.writeLong(tvf.getFilePointer());
150
 
    tvd.writeVInt(perDoc.numVectorFields);
151
 
    if (perDoc.numVectorFields > 0) {
152
 
      for(int i=0;i<perDoc.numVectorFields;i++) {
153
 
        tvd.writeVInt(perDoc.fieldNumbers[i]);
154
 
      }
155
 
      assert 0 == perDoc.fieldPointers[0];
156
 
      long lastPos = perDoc.fieldPointers[0];
157
 
      for(int i=1;i<perDoc.numVectorFields;i++) {
158
 
        long pos = perDoc.fieldPointers[i];
159
 
        tvd.writeVLong(pos-lastPos);
160
 
        lastPos = pos;
161
 
      }
162
 
      perDoc.perDocTvf.writeTo(tvf);
163
 
      perDoc.numVectorFields = 0;
164
 
    }
165
 
 
166
 
    assert lastDocID == perDoc.docID: "lastDocID=" + lastDocID + " perDoc.docID=" + perDoc.docID;
167
 
 
168
 
    lastDocID++;
169
 
 
170
 
    perDoc.reset();
171
 
    free(perDoc);
172
 
    assert docWriter.writer.testPoint("TermVectorsTermsWriter.finishDocument end");
173
 
  }
174
 
 
175
 
  @Override
176
 
  public void abort() {
177
 
    hasVectors = false;
178
 
    try {
179
 
      IOUtils.closeWhileHandlingException(tvx, tvd, tvf);
180
 
    } catch (IOException e) {
181
 
      // cannot happen since we suppress exceptions
182
 
      throw new RuntimeException(e);
183
 
    }
184
 
    
185
 
    try {
186
 
      docWriter.directory.deleteFile(IndexFileNames.segmentFileName(docWriter.getSegment(), IndexFileNames.VECTORS_INDEX_EXTENSION));
187
 
    } catch (IOException ignored) {
188
 
    }
189
 
    
190
 
    try {
191
 
      docWriter.directory.deleteFile(IndexFileNames.segmentFileName(docWriter.getSegment(), IndexFileNames.VECTORS_DOCUMENTS_EXTENSION));
192
 
    } catch (IOException ignored) {
193
 
    }
194
 
    
195
 
    try {
196
 
      docWriter.directory.deleteFile(IndexFileNames.segmentFileName(docWriter.getSegment(), IndexFileNames.VECTORS_FIELDS_EXTENSION));
197
 
    } catch (IOException ignored) {
198
 
    }
199
 
    
200
 
    tvx = tvd = tvf = null;
201
 
    lastDocID = 0;
202
 
  }
203
 
 
204
 
  synchronized void free(PerDoc doc) {
205
 
    assert freeCount < docFreeList.length;
206
 
    docFreeList[freeCount++] = doc;
207
 
  }
208
 
 
209
 
  class PerDoc extends DocumentsWriter.DocWriter {
210
 
 
211
 
    final DocumentsWriter.PerDocBuffer buffer = docWriter.newPerDocBuffer();
212
 
    RAMOutputStream perDocTvf = new RAMOutputStream(buffer);
213
 
 
214
 
    int numVectorFields;
215
 
 
216
 
    int[] fieldNumbers = new int[1];
217
 
    long[] fieldPointers = new long[1];
218
 
 
219
 
    void reset() {
220
 
      perDocTvf.reset();
221
 
      buffer.recycle();
222
 
      numVectorFields = 0;
223
 
    }
224
 
 
225
 
    @Override
226
 
    void abort() {
227
 
      reset();
228
 
      free(this);
229
 
    }
230
 
 
231
 
    void addField(final int fieldNumber) {
232
 
      if (numVectorFields == fieldNumbers.length) {
233
 
        fieldNumbers = ArrayUtil.grow(fieldNumbers);
234
 
      }
235
 
      if (numVectorFields == fieldPointers.length) {
236
 
        fieldPointers = ArrayUtil.grow(fieldPointers);
237
 
      }
238
 
      fieldNumbers[numVectorFields] = fieldNumber;
239
 
      fieldPointers[numVectorFields] = perDocTvf.getFilePointer();
240
 
      numVectorFields++;
241
 
    }
242
 
 
243
 
    @Override
244
 
    public long sizeInBytes() {
245
 
      return buffer.getSizeInBytes();
246
 
    }
247
 
 
248
 
    @Override
249
 
    public void finish() throws IOException {
250
 
      finishDocument(this);
251
 
    }
252
 
  }
253
 
}