You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by rj...@apache.org on 2014/10/21 20:15:33 UTC
svn commit: r1633429 - in /lucene/dev/branches/lucene5969/lucene:
backward-codecs/src/java/org/apache/lucene/codecs/blocktree/
backward-codecs/src/java/org/apache/lucene/codecs/lucene40/
backward-codecs/src/java/org/apache/lucene/codecs/lucene41/ backw...
Author: rjernst
Date: Tue Oct 21 18:15:32 2014
New Revision: 1633429
URL: http://svn.apache.org/r1633429
Log:
LUCENE-5969: Copy block tree to backward codecs for 4.0-4.10, remove conditionals in 50 version, add getStats() TermsEnum API to remove need to expose Stats impl
Added:
lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/
lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40BlockTreeTermsReader.java
- copied, changed from r1633413, lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsReader.java
lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40BlockTreeTermsWriter.java
- copied, changed from r1633413, lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsWriter.java
lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40FieldReader.java
- copied, changed from r1633413, lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/FieldReader.java
lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40IntersectTermsEnum.java
- copied, changed from r1633413, lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/IntersectTermsEnum.java
lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40IntersectTermsEnumFrame.java
- copied, changed from r1633413, lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/IntersectTermsEnumFrame.java
lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40SegmentTermsEnum.java
- copied, changed from r1633413, lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/SegmentTermsEnum.java
lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40SegmentTermsEnumFrame.java
- copied, changed from r1633413, lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/SegmentTermsEnumFrame.java
lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40Stats.java
- copied, changed from r1633413, lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/Stats.java
lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/package.html
- copied, changed from r1633413, lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/package.html
lucene/dev/branches/lucene5969/lucene/backward-codecs/src/test/org/apache/lucene/codecs/blocktree/
lucene/dev/branches/lucene5969/lucene/backward-codecs/src/test/org/apache/lucene/codecs/blocktree/TestLucene40BlockFormat.java
- copied, changed from r1633413, lucene/dev/branches/lucene5969/lucene/backward-codecs/src/test/org/apache/lucene/codecs/lucene41/TestLucene41PostingsFormat.java
Removed:
lucene/dev/branches/lucene5969/lucene/backward-codecs/src/test/org/apache/lucene/codecs/lucene41/TestLucene41PostingsFormat.java
Modified:
lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/lucene40/Lucene40PostingsFormat.java
lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/lucene41/Lucene41PostingsFormat.java
lucene/dev/branches/lucene5969/lucene/backward-codecs/src/test/org/apache/lucene/codecs/lucene40/Lucene40RWPostingsFormat.java
lucene/dev/branches/lucene5969/lucene/backward-codecs/src/test/org/apache/lucene/codecs/lucene41/Lucene41RWPostingsFormat.java
lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsReader.java
lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsWriter.java
lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/index/CheckIndex.java
lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/index/Terms.java
Copied: lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40BlockTreeTermsReader.java (from r1633413, lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsReader.java)
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40BlockTreeTermsReader.java?p2=lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40BlockTreeTermsReader.java&p1=lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsReader.java&r1=1633413&r2=1633429&rev=1633429&view=diff
==============================================================================
--- lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsReader.java (original)
+++ lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40BlockTreeTermsReader.java Tue Oct 21 18:15:32 2014
@@ -64,12 +64,13 @@ import org.apache.lucene.util.IOUtils;
* option to see summary statistics on the blocks in the
* dictionary.
*
- * See {@link BlockTreeTermsWriter}.
+ * See {@link Lucene40BlockTreeTermsWriter}.
*
* @lucene.experimental
+ * @deprecated Only for 4.x backcompat
*/
-
-public final class BlockTreeTermsReader extends FieldsProducer {
+@Deprecated
+public final class Lucene40BlockTreeTermsReader extends FieldsProducer {
// Open input to the main terms dict file (_X.tib)
final IndexInput in;
@@ -80,7 +81,7 @@ public final class BlockTreeTermsReader
// produce DocsEnum on demand
final PostingsReaderBase postingsReader;
- private final TreeMap<String,FieldReader> fields = new TreeMap<>();
+ private final TreeMap<String,Lucene40FieldReader> fields = new TreeMap<>();
/** File offset where the directory starts in the terms file. */
private long dirOffset;
@@ -93,13 +94,13 @@ public final class BlockTreeTermsReader
private final int version;
/** Sole constructor. */
- public BlockTreeTermsReader(PostingsReaderBase postingsReader, SegmentReadState state)
+ public Lucene40BlockTreeTermsReader(PostingsReaderBase postingsReader, SegmentReadState state)
throws IOException {
this.postingsReader = postingsReader;
this.segment = state.segmentInfo.name;
- String termsFileName = IndexFileNames.segmentFileName(segment, state.segmentSuffix, BlockTreeTermsWriter.TERMS_EXTENSION);
+ String termsFileName = IndexFileNames.segmentFileName(segment, state.segmentSuffix, Lucene40BlockTreeTermsWriter.TERMS_EXTENSION);
in = state.directory.openInput(termsFileName, state.context);
boolean success = false;
@@ -107,7 +108,7 @@ public final class BlockTreeTermsReader
try {
version = readHeader(in);
- String indexFileName = IndexFileNames.segmentFileName(segment, state.segmentSuffix, BlockTreeTermsWriter.TERMS_INDEX_EXTENSION);
+ String indexFileName = IndexFileNames.segmentFileName(segment, state.segmentSuffix, Lucene40BlockTreeTermsWriter.TERMS_INDEX_EXTENSION);
indexIn = state.directory.openInput(indexFileName, state.context);
int indexVersion = readIndexHeader(indexIn);
if (indexVersion != version) {
@@ -115,7 +116,7 @@ public final class BlockTreeTermsReader
}
// verify
- if (version >= BlockTreeTermsWriter.VERSION_CHECKSUM) {
+ if (version >= Lucene40BlockTreeTermsWriter.VERSION_CHECKSUM) {
CodecUtil.checksumEntireFile(indexIn);
}
@@ -127,7 +128,7 @@ public final class BlockTreeTermsReader
// but for now we at least verify proper structure of the checksum footer: which looks
// for FOOTER_MAGIC + algorithmID. This is cheap and can detect some forms of corruption
// such as file truncation.
- if (version >= BlockTreeTermsWriter.VERSION_CHECKSUM) {
+ if (version >= Lucene40BlockTreeTermsWriter.VERSION_CHECKSUM) {
CodecUtil.retrieveChecksum(in);
}
@@ -160,12 +161,12 @@ public final class BlockTreeTermsReader
final long sumTotalTermFreq = fieldInfo.getIndexOptions() == IndexOptions.DOCS_ONLY ? -1 : in.readVLong();
final long sumDocFreq = in.readVLong();
final int docCount = in.readVInt();
- final int longsSize = version >= BlockTreeTermsWriter.VERSION_META_ARRAY ? in.readVInt() : 0;
+ final int longsSize = version >= Lucene40BlockTreeTermsWriter.VERSION_META_ARRAY ? in.readVInt() : 0;
if (longsSize < 0) {
throw new CorruptIndexException("invalid longsSize for field: " + fieldInfo.name + ", longsSize=" + longsSize, in);
}
BytesRef minTerm, maxTerm;
- if (version >= BlockTreeTermsWriter.VERSION_MIN_MAX_TERMS) {
+ if (version >= Lucene40BlockTreeTermsWriter.VERSION_MIN_MAX_TERMS) {
minTerm = readBytesRef(in);
maxTerm = readBytesRef(in);
} else {
@@ -181,8 +182,8 @@ public final class BlockTreeTermsReader
throw new CorruptIndexException("invalid sumTotalTermFreq: " + sumTotalTermFreq + " sumDocFreq: " + sumDocFreq, in);
}
final long indexStartFP = indexIn.readVLong();
- FieldReader previous = fields.put(fieldInfo.name,
- new FieldReader(this, fieldInfo, numTerms, rootCode, sumTotalTermFreq, sumDocFreq, docCount,
+ Lucene40FieldReader previous = fields.put(fieldInfo.name,
+ new Lucene40FieldReader(this, fieldInfo, numTerms, rootCode, sumTotalTermFreq, sumDocFreq, docCount,
indexStartFP, longsSize, indexIn, minTerm, maxTerm));
if (previous != null) {
throw new CorruptIndexException("duplicate field: " + fieldInfo.name, in);
@@ -209,10 +210,10 @@ public final class BlockTreeTermsReader
/** Reads terms file header. */
private int readHeader(IndexInput input) throws IOException {
- int version = CodecUtil.checkHeader(input, BlockTreeTermsWriter.TERMS_CODEC_NAME,
- BlockTreeTermsWriter.VERSION_START,
- BlockTreeTermsWriter.VERSION_CURRENT);
- if (version < BlockTreeTermsWriter.VERSION_APPEND_ONLY) {
+ int version = CodecUtil.checkHeader(input, Lucene40BlockTreeTermsWriter.TERMS_CODEC_NAME,
+ Lucene40BlockTreeTermsWriter.VERSION_START,
+ Lucene40BlockTreeTermsWriter.VERSION_CURRENT);
+ if (version < Lucene40BlockTreeTermsWriter.VERSION_APPEND_ONLY) {
dirOffset = input.readLong();
}
return version;
@@ -220,10 +221,10 @@ public final class BlockTreeTermsReader
/** Reads index file header. */
private int readIndexHeader(IndexInput input) throws IOException {
- int version = CodecUtil.checkHeader(input, BlockTreeTermsWriter.TERMS_INDEX_CODEC_NAME,
- BlockTreeTermsWriter.VERSION_START,
- BlockTreeTermsWriter.VERSION_CURRENT);
- if (version < BlockTreeTermsWriter.VERSION_APPEND_ONLY) {
+ int version = CodecUtil.checkHeader(input, Lucene40BlockTreeTermsWriter.TERMS_INDEX_CODEC_NAME,
+ Lucene40BlockTreeTermsWriter.VERSION_START,
+ Lucene40BlockTreeTermsWriter.VERSION_CURRENT);
+ if (version < Lucene40BlockTreeTermsWriter.VERSION_APPEND_ONLY) {
indexDirOffset = input.readLong();
}
return version;
@@ -232,10 +233,10 @@ public final class BlockTreeTermsReader
/** Seek {@code input} to the directory offset. */
private void seekDir(IndexInput input, long dirOffset)
throws IOException {
- if (version >= BlockTreeTermsWriter.VERSION_CHECKSUM) {
+ if (version >= Lucene40BlockTreeTermsWriter.VERSION_CHECKSUM) {
input.seek(input.length() - CodecUtil.footerLength() - 8);
dirOffset = input.readLong();
- } else if (version >= BlockTreeTermsWriter.VERSION_APPEND_ONLY) {
+ } else if (version >= Lucene40BlockTreeTermsWriter.VERSION_APPEND_ONLY) {
input.seek(input.length() - 8);
dirOffset = input.readLong();
}
@@ -293,7 +294,7 @@ public final class BlockTreeTermsReader
@Override
public long ramBytesUsed() {
long sizeInBytes = postingsReader.ramBytesUsed();
- for(FieldReader reader : fields.values()) {
+ for(Lucene40FieldReader reader : fields.values()) {
sizeInBytes += reader.ramBytesUsed();
}
return sizeInBytes;
@@ -309,7 +310,7 @@ public final class BlockTreeTermsReader
@Override
public void checkIntegrity() throws IOException {
- if (version >= BlockTreeTermsWriter.VERSION_CHECKSUM) {
+ if (version >= Lucene40BlockTreeTermsWriter.VERSION_CHECKSUM) {
// term dictionary
CodecUtil.checksumEntireFile(in);
Copied: lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40BlockTreeTermsWriter.java (from r1633413, lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsWriter.java)
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40BlockTreeTermsWriter.java?p2=lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40BlockTreeTermsWriter.java&p1=lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsWriter.java&r1=1633413&r2=1633429&rev=1633429&view=diff
==============================================================================
--- lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsWriter.java (original)
+++ lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40BlockTreeTermsWriter.java Tue Oct 21 18:15:32 2014
@@ -41,7 +41,6 @@ import org.apache.lucene.util.BytesRef;
import org.apache.lucene.util.BytesRefBuilder;
import org.apache.lucene.util.FixedBitSet;
import org.apache.lucene.util.IOUtils;
-import org.apache.lucene.util.IntsRef;
import org.apache.lucene.util.IntsRefBuilder;
import org.apache.lucene.util.StringHelper;
import org.apache.lucene.util.fst.Builder;
@@ -187,10 +186,12 @@ import org.apache.lucene.util.packed.Pac
* sub-block, and its file pointer.
* </ul>
*
- * @see BlockTreeTermsReader
+ * @see Lucene40BlockTreeTermsReader
* @lucene.experimental
+ * @deprecated Only for 4.x backcompat
*/
-public final class BlockTreeTermsWriter extends FieldsConsumer {
+@Deprecated
+public final class Lucene40BlockTreeTermsWriter extends FieldsConsumer {
static final Outputs<BytesRef> FST_OUTPUTS = ByteSequenceOutputs.getSingleton();
@@ -198,12 +199,12 @@ public final class BlockTreeTermsWriter
/** Suggested default value for the {@code
* minItemsInBlock} parameter to {@link
- * #BlockTreeTermsWriter(SegmentWriteState,PostingsWriterBase,int,int)}. */
+ * #Lucene40BlockTreeTermsWriter(SegmentWriteState,PostingsWriterBase,int,int)}. */
public final static int DEFAULT_MIN_BLOCK_SIZE = 25;
/** Suggested default value for the {@code
* maxItemsInBlock} parameter to {@link
- * #BlockTreeTermsWriter(SegmentWriteState,PostingsWriterBase,int,int)}. */
+ * #Lucene40BlockTreeTermsWriter(SegmentWriteState,PostingsWriterBase,int,int)}. */
public final static int DEFAULT_MAX_BLOCK_SIZE = 48;
// public final static boolean DEBUG = false;
@@ -286,11 +287,11 @@ public final class BlockTreeTermsWriter
* sub-blocks) per block will aim to be between
* minItemsPerBlock and maxItemsPerBlock, though in some
* cases the blocks may be smaller than the min. */
- public BlockTreeTermsWriter(
- SegmentWriteState state,
- PostingsWriterBase postingsWriter,
- int minItemsInBlock,
- int maxItemsInBlock)
+ public Lucene40BlockTreeTermsWriter(
+ SegmentWriteState state,
+ PostingsWriterBase postingsWriter,
+ int minItemsInBlock,
+ int maxItemsInBlock)
throws IOException
{
if (minItemsInBlock <= 1) {
Copied: lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40FieldReader.java (from r1633413, lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/FieldReader.java)
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40FieldReader.java?p2=lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40FieldReader.java&p1=lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/FieldReader.java&r1=1633413&r2=1633429&rev=1633429&view=diff
==============================================================================
--- lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/FieldReader.java (original)
+++ lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40FieldReader.java Tue Oct 21 18:15:32 2014
@@ -34,12 +34,15 @@ import org.apache.lucene.util.automaton.
import org.apache.lucene.util.fst.ByteSequenceOutputs;
import org.apache.lucene.util.fst.FST;
-/** BlockTree's implementation of {@link Terms}. */
-// public for CheckIndex:
-public final class FieldReader extends Terms implements Accountable {
+/**
+ * BlockTree's implementation of {@link Terms}.
+ * @deprecated Only for 4.x backcompat
+ */
+@Deprecated
+final class Lucene40FieldReader extends Terms implements Accountable {
private static final long BASE_RAM_BYTES_USED =
- RamUsageEstimator.shallowSizeOfInstance(FieldReader.class)
+ RamUsageEstimator.shallowSizeOfInstance(Lucene40FieldReader.class)
+ 3 * RamUsageEstimator.shallowSizeOfInstance(BytesRef.class);
final long numTerms;
@@ -53,13 +56,13 @@ public final class FieldReader extends T
final BytesRef minTerm;
final BytesRef maxTerm;
final int longsSize;
- final BlockTreeTermsReader parent;
+ final Lucene40BlockTreeTermsReader parent;
final FST<BytesRef> index;
//private boolean DEBUG;
- FieldReader(BlockTreeTermsReader parent, FieldInfo fieldInfo, long numTerms, BytesRef rootCode, long sumTotalTermFreq, long sumDocFreq, int docCount,
- long indexStartFP, int longsSize, IndexInput indexIn, BytesRef minTerm, BytesRef maxTerm) throws IOException {
+ Lucene40FieldReader(Lucene40BlockTreeTermsReader parent, FieldInfo fieldInfo, long numTerms, BytesRef rootCode, long sumTotalTermFreq, long sumDocFreq, int docCount,
+ long indexStartFP, int longsSize, IndexInput indexIn, BytesRef minTerm, BytesRef maxTerm) throws IOException {
assert numTerms > 0;
this.fieldInfo = fieldInfo;
//DEBUG = BlockTreeTermsReader.DEBUG && fieldInfo.name.equals("id");
@@ -77,7 +80,7 @@ public final class FieldReader extends T
// System.out.println("BTTR: seg=" + segment + " field=" + fieldInfo.name + " rootBlockCode=" + rootCode + " divisor=" + indexDivisor);
// }
- rootBlockFP = (new ByteArrayDataInput(rootCode.bytes, rootCode.offset, rootCode.length)).readVLong() >>> BlockTreeTermsWriter.OUTPUT_FLAGS_NUM_BITS;
+ rootBlockFP = (new ByteArrayDataInput(rootCode.bytes, rootCode.offset, rootCode.length)).readVLong() >>> Lucene40BlockTreeTermsWriter.OUTPUT_FLAGS_NUM_BITS;
if (indexIn != null) {
final IndexInput clone = indexIn.clone();
@@ -121,8 +124,8 @@ public final class FieldReader extends T
/** For debugging -- used by CheckIndex too*/
// TODO: maybe push this into Terms?
- public Stats computeStats() throws IOException {
- return new SegmentTermsEnum(this).computeBlockStats();
+ public Lucene40Stats computeStats() throws IOException {
+ return new Lucene40SegmentTermsEnum(this).computeBlockStats();
}
@Override
@@ -147,7 +150,7 @@ public final class FieldReader extends T
@Override
public TermsEnum iterator(TermsEnum reuse) throws IOException {
- return new SegmentTermsEnum(this);
+ return new Lucene40SegmentTermsEnum(this);
}
@Override
@@ -175,7 +178,7 @@ public final class FieldReader extends T
if (compiled.type != CompiledAutomaton.AUTOMATON_TYPE.NORMAL) {
throw new IllegalArgumentException("please use CompiledAutomaton.getTermsEnum instead");
}
- return new IntersectTermsEnum(this, compiled, startTerm);
+ return new Lucene40IntersectTermsEnum(this, compiled, startTerm);
}
@Override
Copied: lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40IntersectTermsEnum.java (from r1633413, lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/IntersectTermsEnum.java)
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40IntersectTermsEnum.java?p2=lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40IntersectTermsEnum.java&p1=lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/IntersectTermsEnum.java&r1=1633413&r2=1633429&rev=1633429&view=diff
==============================================================================
--- lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/IntersectTermsEnum.java (original)
+++ lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40IntersectTermsEnum.java Tue Oct 21 18:15:32 2014
@@ -37,30 +37,35 @@ import org.apache.lucene.util.fst.FST;
import org.apache.lucene.util.fst.Outputs;
// NOTE: cannot seek!
-final class IntersectTermsEnum extends TermsEnum {
+
+/**
+ * @deprecated Only for 4.x backcompat
+ */
+@Deprecated
+final class Lucene40IntersectTermsEnum extends TermsEnum {
final IndexInput in;
final static Outputs<BytesRef> fstOutputs = ByteSequenceOutputs.getSingleton();
- private IntersectTermsEnumFrame[] stack;
+ private Lucene40IntersectTermsEnumFrame[] stack;
@SuppressWarnings({"rawtypes","unchecked"}) private FST.Arc<BytesRef>[] arcs = new FST.Arc[5];
final RunAutomaton runAutomaton;
final CompiledAutomaton compiledAutomaton;
- private IntersectTermsEnumFrame currentFrame;
+ private Lucene40IntersectTermsEnumFrame currentFrame;
private final BytesRef term = new BytesRef();
private final FST.BytesReader fstReader;
- final FieldReader fr;
+ final Lucene40FieldReader fr;
private BytesRef savedStartTerm;
// TODO: in some cases we can filter by length? eg
// regexp foo*bar must be at least length 6 bytes
- public IntersectTermsEnum(FieldReader fr, CompiledAutomaton compiled, BytesRef startTerm) throws IOException {
+ public Lucene40IntersectTermsEnum(Lucene40FieldReader fr, CompiledAutomaton compiled, BytesRef startTerm) throws IOException {
// if (DEBUG) {
// System.out.println("\nintEnum.init seg=" + segment + " commonSuffix=" + brToString(compiled.commonSuffixRef));
// }
@@ -68,9 +73,9 @@ final class IntersectTermsEnum extends T
runAutomaton = compiled.runAutomaton;
compiledAutomaton = compiled;
in = fr.parent.in.clone();
- stack = new IntersectTermsEnumFrame[5];
+ stack = new Lucene40IntersectTermsEnumFrame[5];
for(int idx=0;idx<stack.length;idx++) {
- stack[idx] = new IntersectTermsEnumFrame(this, idx);
+ stack[idx] = new Lucene40IntersectTermsEnumFrame(this, idx);
}
for(int arcIdx=0;arcIdx<arcs.length;arcIdx++) {
arcs[arcIdx] = new FST.Arc<>();
@@ -94,7 +99,7 @@ final class IntersectTermsEnum extends T
assert arc.isFinal();
// Special pushFrame since it's the first one:
- final IntersectTermsEnumFrame f = stack[0];
+ final Lucene40IntersectTermsEnumFrame f = stack[0];
f.fp = f.fpOrig = fr.rootBlockFP;
f.prefix = 0;
f.setState(runAutomaton.getInitialState());
@@ -123,12 +128,12 @@ final class IntersectTermsEnum extends T
return currentFrame.termState.clone();
}
- private IntersectTermsEnumFrame getFrame(int ord) throws IOException {
+ private Lucene40IntersectTermsEnumFrame getFrame(int ord) throws IOException {
if (ord >= stack.length) {
- final IntersectTermsEnumFrame[] next = new IntersectTermsEnumFrame[ArrayUtil.oversize(1+ord, RamUsageEstimator.NUM_BYTES_OBJECT_REF)];
+ final Lucene40IntersectTermsEnumFrame[] next = new Lucene40IntersectTermsEnumFrame[ArrayUtil.oversize(1+ord, RamUsageEstimator.NUM_BYTES_OBJECT_REF)];
System.arraycopy(stack, 0, next, 0, stack.length);
for(int stackOrd=stack.length;stackOrd<next.length;stackOrd++) {
- next[stackOrd] = new IntersectTermsEnumFrame(this, stackOrd);
+ next[stackOrd] = new Lucene40IntersectTermsEnumFrame(this, stackOrd);
}
stack = next;
}
@@ -149,8 +154,8 @@ final class IntersectTermsEnum extends T
return arcs[ord];
}
- private IntersectTermsEnumFrame pushFrame(int state) throws IOException {
- final IntersectTermsEnumFrame f = getFrame(currentFrame == null ? 0 : 1+currentFrame.ord);
+ private Lucene40IntersectTermsEnumFrame pushFrame(int state) throws IOException {
+ final Lucene40IntersectTermsEnumFrame f = getFrame(currentFrame == null ? 0 : 1+currentFrame.ord);
f.fp = f.fpOrig = currentFrame.lastSubFP;
f.prefix = currentFrame.prefix + currentFrame.suffix;
Copied: lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40IntersectTermsEnumFrame.java (from r1633413, lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/IntersectTermsEnumFrame.java)
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40IntersectTermsEnumFrame.java?p2=lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40IntersectTermsEnumFrame.java&p1=lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/IntersectTermsEnumFrame.java&r1=1633413&r2=1633429&rev=1633429&view=diff
==============================================================================
--- lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/IntersectTermsEnumFrame.java (original)
+++ lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40IntersectTermsEnumFrame.java Tue Oct 21 18:15:32 2014
@@ -27,8 +27,14 @@ import org.apache.lucene.util.BytesRef;
import org.apache.lucene.util.automaton.Transition;
import org.apache.lucene.util.fst.FST;
+
+
+/**
+ * @deprecated Only for 4.x backcompat
+ */
// TODO: can we share this with the frame in STE?
-final class IntersectTermsEnumFrame {
+@Deprecated
+final class Lucene40IntersectTermsEnumFrame {
final int ord;
long fp;
long fpOrig;
@@ -89,9 +95,9 @@ final class IntersectTermsEnumFrame {
int startBytePos;
int suffix;
- private final IntersectTermsEnum ite;
+ private final Lucene40IntersectTermsEnum ite;
- public IntersectTermsEnumFrame(IntersectTermsEnum ite, int ord) throws IOException {
+ public Lucene40IntersectTermsEnumFrame(Lucene40IntersectTermsEnum ite, int ord) throws IOException {
this.ite = ite;
this.ord = ord;
this.termState = ite.fr.parent.postingsReader.newTermState();
@@ -145,7 +151,7 @@ final class IntersectTermsEnumFrame {
// Skip first long -- has redundant fp, hasTerms
// flag, isFloor flag
final long code = floorDataReader.readVLong();
- if ((code & BlockTreeTermsWriter.OUTPUT_FLAG_IS_FLOOR) != 0) {
+ if ((code & Lucene40BlockTreeTermsWriter.OUTPUT_FLAG_IS_FLOOR) != 0) {
numFollowFloorBlocks = floorDataReader.readVInt();
nextFloorLabel = floorDataReader.readByte() & 0xff;
// if (DEBUG) System.out.println(" numFollowFloorBlocks=" + numFollowFloorBlocks + " nextFloorLabel=" + nextFloorLabel);
Copied: lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40SegmentTermsEnum.java (from r1633413, lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/SegmentTermsEnum.java)
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40SegmentTermsEnum.java?p2=lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40SegmentTermsEnum.java&p1=lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/SegmentTermsEnum.java&r1=1633413&r2=1633429&rev=1633429&view=diff
==============================================================================
--- lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/SegmentTermsEnum.java (original)
+++ lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40SegmentTermsEnum.java Tue Oct 21 18:15:32 2014
@@ -36,17 +36,21 @@ import org.apache.lucene.util.RamUsageEs
import org.apache.lucene.util.fst.FST;
import org.apache.lucene.util.fst.Util;
-/** Iterates through terms in this field */
-final class SegmentTermsEnum extends TermsEnum {
+/**
+ * Iterates through terms in this field
+ * @deprecated Only for 4.x backcompat
+ */
+@Deprecated
+final class Lucene40SegmentTermsEnum extends TermsEnum {
// Lazy init:
IndexInput in;
- private SegmentTermsEnumFrame[] stack;
- private final SegmentTermsEnumFrame staticFrame;
- SegmentTermsEnumFrame currentFrame;
+ private Lucene40SegmentTermsEnumFrame[] stack;
+ private final Lucene40SegmentTermsEnumFrame staticFrame;
+ Lucene40SegmentTermsEnumFrame currentFrame;
boolean termExists;
- final FieldReader fr;
+ final Lucene40FieldReader fr;
private int targetBeforeCurrentLength;
@@ -66,16 +70,16 @@ final class SegmentTermsEnum extends Ter
@SuppressWarnings({"rawtypes","unchecked"}) private FST.Arc<BytesRef>[] arcs = new FST.Arc[1];
- public SegmentTermsEnum(FieldReader fr) throws IOException {
+ public Lucene40SegmentTermsEnum(Lucene40FieldReader fr) throws IOException {
this.fr = fr;
// if (DEBUG) {
// System.out.println("BTTR.init seg=" + fr.parent.segment);
// }
- stack = new SegmentTermsEnumFrame[0];
+ stack = new Lucene40SegmentTermsEnumFrame[0];
// Used to hold seek by TermState, or cached seek
- staticFrame = new SegmentTermsEnumFrame(this, -1);
+ staticFrame = new Lucene40SegmentTermsEnumFrame(this, -1);
if (fr.index == null) {
fstReader = null;
@@ -119,9 +123,9 @@ final class SegmentTermsEnum extends Ter
/** Runs next() through the entire terms dict,
* computing aggregate statistics. */
- public Stats computeBlockStats() throws IOException {
+ public Lucene40Stats computeBlockStats() throws IOException {
- Stats stats = new Stats(fr.parent.segment, fr.fieldInfo.name);
+ Lucene40Stats stats = new Lucene40Stats(fr.parent.segment, fr.fieldInfo.name);
if (fr.index != null) {
stats.indexNodeCount = fr.index.getNodeCount();
stats.indexArcCount = fr.index.getArcCount();
@@ -208,12 +212,12 @@ final class SegmentTermsEnum extends Ter
return stats;
}
- private SegmentTermsEnumFrame getFrame(int ord) throws IOException {
+ private Lucene40SegmentTermsEnumFrame getFrame(int ord) throws IOException {
if (ord >= stack.length) {
- final SegmentTermsEnumFrame[] next = new SegmentTermsEnumFrame[ArrayUtil.oversize(1+ord, RamUsageEstimator.NUM_BYTES_OBJECT_REF)];
+ final Lucene40SegmentTermsEnumFrame[] next = new Lucene40SegmentTermsEnumFrame[ArrayUtil.oversize(1+ord, RamUsageEstimator.NUM_BYTES_OBJECT_REF)];
System.arraycopy(stack, 0, next, 0, stack.length);
for(int stackOrd=stack.length;stackOrd<next.length;stackOrd++) {
- next[stackOrd] = new SegmentTermsEnumFrame(this, stackOrd);
+ next[stackOrd] = new Lucene40SegmentTermsEnumFrame(this, stackOrd);
}
stack = next;
}
@@ -235,14 +239,14 @@ final class SegmentTermsEnum extends Ter
}
// Pushes a frame we seek'd to
- SegmentTermsEnumFrame pushFrame(FST.Arc<BytesRef> arc, BytesRef frameData, int length) throws IOException {
+ Lucene40SegmentTermsEnumFrame pushFrame(FST.Arc<BytesRef> arc, BytesRef frameData, int length) throws IOException {
scratchReader.reset(frameData.bytes, frameData.offset, frameData.length);
final long code = scratchReader.readVLong();
- final long fpSeek = code >>> BlockTreeTermsWriter.OUTPUT_FLAGS_NUM_BITS;
- final SegmentTermsEnumFrame f = getFrame(1+currentFrame.ord);
- f.hasTerms = (code & BlockTreeTermsWriter.OUTPUT_FLAG_HAS_TERMS) != 0;
+ final long fpSeek = code >>> Lucene40BlockTreeTermsWriter.OUTPUT_FLAGS_NUM_BITS;
+ final Lucene40SegmentTermsEnumFrame f = getFrame(1+currentFrame.ord);
+ f.hasTerms = (code & Lucene40BlockTreeTermsWriter.OUTPUT_FLAG_HAS_TERMS) != 0;
f.hasTermsOrig = f.hasTerms;
- f.isFloor = (code & BlockTreeTermsWriter.OUTPUT_FLAG_IS_FLOOR) != 0;
+ f.isFloor = (code & Lucene40BlockTreeTermsWriter.OUTPUT_FLAG_IS_FLOOR) != 0;
if (f.isFloor) {
f.setFloorData(scratchReader, frameData);
}
@@ -253,8 +257,8 @@ final class SegmentTermsEnum extends Ter
// Pushes next'd frame or seek'd frame; we later
// lazy-load the frame only when needed
- SegmentTermsEnumFrame pushFrame(FST.Arc<BytesRef> arc, long fp, int length) throws IOException {
- final SegmentTermsEnumFrame f = getFrame(1+currentFrame.ord);
+ Lucene40SegmentTermsEnumFrame pushFrame(FST.Arc<BytesRef> arc, long fp, int length) throws IOException {
+ final Lucene40SegmentTermsEnumFrame f = getFrame(1+currentFrame.ord);
f.arc = arc;
if (f.fpOrig == fp && f.nextEnt != -1) {
//if (DEBUG) System.out.println(" push reused frame ord=" + f.ord + " fp=" + f.fp + " isFloor?=" + f.isFloor + " hasTerms=" + f.hasTerms + " pref=" + term + " nextEnt=" + f.nextEnt + " targetBeforeCurrentLength=" + targetBeforeCurrentLength + " term.length=" + term.length + " vs prefix=" + f.prefix);
@@ -349,7 +353,7 @@ final class SegmentTermsEnum extends Ter
output = arc.output;
targetUpto = 0;
- SegmentTermsEnumFrame lastFrame = stack[0];
+ Lucene40SegmentTermsEnumFrame lastFrame = stack[0];
assert validIndexPrefix <= term.length();
final int targetLimit = Math.min(target.length, validIndexPrefix);
@@ -370,8 +374,8 @@ final class SegmentTermsEnum extends Ter
}
arc = arcs[1+targetUpto];
assert arc.label == (target.bytes[target.offset + targetUpto] & 0xFF): "arc.label=" + (char) arc.label + " targetLabel=" + (char) (target.bytes[target.offset + targetUpto] & 0xFF);
- if (arc.output != BlockTreeTermsWriter.NO_OUTPUT) {
- output = BlockTreeTermsWriter.FST_OUTPUTS.add(output, arc.output);
+ if (arc.output != Lucene40BlockTreeTermsWriter.NO_OUTPUT) {
+ output = Lucene40BlockTreeTermsWriter.FST_OUTPUTS.add(output, arc.output);
}
if (arc.isFinal()) {
lastFrame = stack[1+lastFrame.ord];
@@ -461,7 +465,7 @@ final class SegmentTermsEnum extends Ter
//term.length = 0;
targetUpto = 0;
- currentFrame = pushFrame(arc, BlockTreeTermsWriter.FST_OUTPUTS.add(output, arc.nextFinalOutput), 0);
+ currentFrame = pushFrame(arc, Lucene40BlockTreeTermsWriter.FST_OUTPUTS.add(output, arc.nextFinalOutput), 0);
}
// if (DEBUG) {
@@ -517,8 +521,8 @@ final class SegmentTermsEnum extends Ter
term.setByteAt(targetUpto, (byte) targetLabel);
// Aggregate output as we go:
assert arc.output != null;
- if (arc.output != BlockTreeTermsWriter.NO_OUTPUT) {
- output = BlockTreeTermsWriter.FST_OUTPUTS.add(output, arc.output);
+ if (arc.output != Lucene40BlockTreeTermsWriter.NO_OUTPUT) {
+ output = Lucene40BlockTreeTermsWriter.FST_OUTPUTS.add(output, arc.output);
}
// if (DEBUG) {
@@ -528,7 +532,7 @@ final class SegmentTermsEnum extends Ter
if (arc.isFinal()) {
//if (DEBUG) System.out.println(" arc is final!");
- currentFrame = pushFrame(arc, BlockTreeTermsWriter.FST_OUTPUTS.add(output, arc.nextFinalOutput), targetUpto);
+ currentFrame = pushFrame(arc, Lucene40BlockTreeTermsWriter.FST_OUTPUTS.add(output, arc.nextFinalOutput), targetUpto);
//if (DEBUG) System.out.println(" curFrame.ord=" + currentFrame.ord + " hasTerms=" + currentFrame.hasTerms);
}
}
@@ -605,7 +609,7 @@ final class SegmentTermsEnum extends Ter
output = arc.output;
targetUpto = 0;
- SegmentTermsEnumFrame lastFrame = stack[0];
+ Lucene40SegmentTermsEnumFrame lastFrame = stack[0];
assert validIndexPrefix <= term.length();
final int targetLimit = Math.min(target.length, validIndexPrefix);
@@ -631,8 +635,8 @@ final class SegmentTermsEnum extends Ter
// seek; but, often the FST doesn't have any
// shared bytes (but this could change if we
// reverse vLong byte order)
- if (arc.output != BlockTreeTermsWriter.NO_OUTPUT) {
- output = BlockTreeTermsWriter.FST_OUTPUTS.add(output, arc.output);
+ if (arc.output != Lucene40BlockTreeTermsWriter.NO_OUTPUT) {
+ output = Lucene40BlockTreeTermsWriter.FST_OUTPUTS.add(output, arc.output);
}
if (arc.isFinal()) {
lastFrame = stack[1+lastFrame.ord];
@@ -717,7 +721,7 @@ final class SegmentTermsEnum extends Ter
//term.length = 0;
targetUpto = 0;
- currentFrame = pushFrame(arc, BlockTreeTermsWriter.FST_OUTPUTS.add(output, arc.nextFinalOutput), 0);
+ currentFrame = pushFrame(arc, Lucene40BlockTreeTermsWriter.FST_OUTPUTS.add(output, arc.nextFinalOutput), 0);
}
//if (DEBUG) {
@@ -773,8 +777,8 @@ final class SegmentTermsEnum extends Ter
arc = nextArc;
// Aggregate output as we go:
assert arc.output != null;
- if (arc.output != BlockTreeTermsWriter.NO_OUTPUT) {
- output = BlockTreeTermsWriter.FST_OUTPUTS.add(output, arc.output);
+ if (arc.output != Lucene40BlockTreeTermsWriter.NO_OUTPUT) {
+ output = Lucene40BlockTreeTermsWriter.FST_OUTPUTS.add(output, arc.output);
}
//if (DEBUG) {
@@ -784,7 +788,7 @@ final class SegmentTermsEnum extends Ter
if (arc.isFinal()) {
//if (DEBUG) System.out.println(" arc is final!");
- currentFrame = pushFrame(arc, BlockTreeTermsWriter.FST_OUTPUTS.add(output, arc.nextFinalOutput), targetUpto);
+ currentFrame = pushFrame(arc, Lucene40BlockTreeTermsWriter.FST_OUTPUTS.add(output, arc.nextFinalOutput), targetUpto);
//if (DEBUG) System.out.println(" curFrame.ord=" + currentFrame.ord + " hasTerms=" + currentFrame.hasTerms);
}
}
@@ -827,13 +831,13 @@ final class SegmentTermsEnum extends Ter
int ord = 0;
boolean isSeekFrame = true;
while(true) {
- SegmentTermsEnumFrame f = getFrame(ord);
+ Lucene40SegmentTermsEnumFrame f = getFrame(ord);
assert f != null;
final BytesRef prefix = new BytesRef(term.get().bytes, 0, f.prefix);
if (f.nextEnt == -1) {
- out.println(" frame " + (isSeekFrame ? "(seek)" : "(next)") + " ord=" + ord + " fp=" + f.fp + (f.isFloor ? (" (fpOrig=" + f.fpOrig + ")") : "") + " prefixLen=" + f.prefix + " prefix=" + prefix + (f.nextEnt == -1 ? "" : (" (of " + f.entCount + ")")) + " hasTerms=" + f.hasTerms + " isFloor=" + f.isFloor + " code=" + ((f.fp<<BlockTreeTermsWriter.OUTPUT_FLAGS_NUM_BITS) + (f.hasTerms ? BlockTreeTermsWriter.OUTPUT_FLAG_HAS_TERMS:0) + (f.isFloor ? BlockTreeTermsWriter.OUTPUT_FLAG_IS_FLOOR:0)) + " isLastInFloor=" + f.isLastInFloor + " mdUpto=" + f.metaDataUpto + " tbOrd=" + f.getTermBlockOrd());
+ out.println(" frame " + (isSeekFrame ? "(seek)" : "(next)") + " ord=" + ord + " fp=" + f.fp + (f.isFloor ? (" (fpOrig=" + f.fpOrig + ")") : "") + " prefixLen=" + f.prefix + " prefix=" + prefix + (f.nextEnt == -1 ? "" : (" (of " + f.entCount + ")")) + " hasTerms=" + f.hasTerms + " isFloor=" + f.isFloor + " code=" + ((f.fp<< Lucene40BlockTreeTermsWriter.OUTPUT_FLAGS_NUM_BITS) + (f.hasTerms ? Lucene40BlockTreeTermsWriter.OUTPUT_FLAG_HAS_TERMS:0) + (f.isFloor ? Lucene40BlockTreeTermsWriter.OUTPUT_FLAG_IS_FLOOR:0)) + " isLastInFloor=" + f.isLastInFloor + " mdUpto=" + f.metaDataUpto + " tbOrd=" + f.getTermBlockOrd());
} else {
- out.println(" frame " + (isSeekFrame ? "(seek, loaded)" : "(next, loaded)") + " ord=" + ord + " fp=" + f.fp + (f.isFloor ? (" (fpOrig=" + f.fpOrig + ")") : "") + " prefixLen=" + f.prefix + " prefix=" + prefix + " nextEnt=" + f.nextEnt + (f.nextEnt == -1 ? "" : (" (of " + f.entCount + ")")) + " hasTerms=" + f.hasTerms + " isFloor=" + f.isFloor + " code=" + ((f.fp<<BlockTreeTermsWriter.OUTPUT_FLAGS_NUM_BITS) + (f.hasTerms ? BlockTreeTermsWriter.OUTPUT_FLAG_HAS_TERMS:0) + (f.isFloor ? BlockTreeTermsWriter.OUTPUT_FLAG_IS_FLOOR:0)) + " lastSubFP=" + f.lastSubFP + " isLastInFloor=" + f.isLastInFloor + " mdUpto=" + f.metaDataUpto + " tbOrd=" + f.getTermBlockOrd());
+ out.println(" frame " + (isSeekFrame ? "(seek, loaded)" : "(next, loaded)") + " ord=" + ord + " fp=" + f.fp + (f.isFloor ? (" (fpOrig=" + f.fpOrig + ")") : "") + " prefixLen=" + f.prefix + " prefix=" + prefix + " nextEnt=" + f.nextEnt + (f.nextEnt == -1 ? "" : (" (of " + f.entCount + ")")) + " hasTerms=" + f.hasTerms + " isFloor=" + f.isFloor + " code=" + ((f.fp<< Lucene40BlockTreeTermsWriter.OUTPUT_FLAGS_NUM_BITS) + (f.hasTerms ? Lucene40BlockTreeTermsWriter.OUTPUT_FLAG_HAS_TERMS:0) + (f.isFloor ? Lucene40BlockTreeTermsWriter.OUTPUT_FLAG_IS_FLOOR:0)) + " lastSubFP=" + f.lastSubFP + " isLastInFloor=" + f.isLastInFloor + " mdUpto=" + f.metaDataUpto + " tbOrd=" + f.getTermBlockOrd());
}
if (fr.index != null) {
assert !isSeekFrame || f.arc != null: "isSeekFrame=" + isSeekFrame + " f.arc=" + f.arc;
@@ -848,7 +852,7 @@ final class SegmentTermsEnum extends Ter
} else if (isSeekFrame && !f.isFloor) {
final ByteArrayDataInput reader = new ByteArrayDataInput(output.bytes, output.offset, output.length);
final long codeOrig = reader.readVLong();
- final long code = (f.fp << BlockTreeTermsWriter.OUTPUT_FLAGS_NUM_BITS) | (f.hasTerms ? BlockTreeTermsWriter.OUTPUT_FLAG_HAS_TERMS:0) | (f.isFloor ? BlockTreeTermsWriter.OUTPUT_FLAG_IS_FLOOR:0);
+ final long code = (f.fp << Lucene40BlockTreeTermsWriter.OUTPUT_FLAGS_NUM_BITS) | (f.hasTerms ? Lucene40BlockTreeTermsWriter.OUTPUT_FLAG_HAS_TERMS:0) | (f.isFloor ? Lucene40BlockTreeTermsWriter.OUTPUT_FLAG_IS_FLOOR:0);
if (codeOrig != code) {
out.println(" broken seek state: output code=" + codeOrig + " doesn't match frame code=" + code);
throw new RuntimeException("seek state is broken");
Copied: lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40SegmentTermsEnumFrame.java (from r1633413, lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/SegmentTermsEnumFrame.java)
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40SegmentTermsEnumFrame.java?p2=lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40SegmentTermsEnumFrame.java&p1=lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/SegmentTermsEnumFrame.java&r1=1633413&r2=1633429&rev=1633429&view=diff
==============================================================================
--- lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/SegmentTermsEnumFrame.java (original)
+++ lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40SegmentTermsEnumFrame.java Tue Oct 21 18:15:32 2014
@@ -27,7 +27,11 @@ import org.apache.lucene.util.ArrayUtil;
import org.apache.lucene.util.BytesRef;
import org.apache.lucene.util.fst.FST;
-final class SegmentTermsEnumFrame {
+/**
+ * @deprecated Only for 4.x backcompat
+ */
+@Deprecated
+final class Lucene40SegmentTermsEnumFrame {
// Our index in stack[]:
final int ord;
@@ -88,9 +92,9 @@ final class SegmentTermsEnumFrame {
public byte[] bytes;
ByteArrayDataInput bytesReader;
- private final SegmentTermsEnum ste;
+ private final Lucene40SegmentTermsEnum ste;
- public SegmentTermsEnumFrame(SegmentTermsEnum ste, int ord) throws IOException {
+ public Lucene40SegmentTermsEnumFrame(Lucene40SegmentTermsEnum ste, int ord) throws IOException {
this.ste = ste;
this.ord = ord;
this.state = ste.fr.parent.postingsReader.newTermState();
Copied: lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40Stats.java (from r1633413, lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/Stats.java)
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40Stats.java?p2=lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40Stats.java&p1=lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/Stats.java&r1=1633413&r2=1633429&rev=1633429&view=diff
==============================================================================
--- lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/Stats.java (original)
+++ lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/Lucene40Stats.java Tue Oct 21 18:15:32 2014
@@ -29,9 +29,11 @@ import org.apache.lucene.util.IOUtils;
/**
* BlockTree statistics for a single field
- * returned by {@link FieldReader#computeStats()}.
+ * returned by {@link Lucene40FieldReader#computeStats()}.
+ * @deprecated Only for 4.x backcompat
*/
-public class Stats {
+@Deprecated
+final class Lucene40Stats {
/** How many nodes in the index FST. */
public long indexNodeCount;
@@ -95,12 +97,12 @@ public class Stats {
/** Field name. */
public final String field;
- Stats(String segment, String field) {
+ Lucene40Stats(String segment, String field) {
this.segment = segment;
this.field = field;
}
- void startBlock(SegmentTermsEnumFrame frame, boolean isFloor) {
+ void startBlock(Lucene40SegmentTermsEnumFrame frame, boolean isFloor) {
totalBlockCount++;
if (isFloor) {
if (frame.fp == frame.fpOrig) {
@@ -120,7 +122,7 @@ public class Stats {
totalBlockStatsBytes += frame.statsReader.length();
}
- void endBlock(SegmentTermsEnumFrame frame) {
+ void endBlock(Lucene40SegmentTermsEnumFrame frame) {
final int termCount = frame.isLeafBlock ? frame.entCount : frame.state.termBlockOrd;
final int subBlockCount = frame.entCount - termCount;
totalTermCount += termCount;
Copied: lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/package.html (from r1633413, lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/package.html)
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/package.html?p2=lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/package.html&p1=lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/package.html&r1=1633413&r2=1633429&rev=1633429&view=diff
==============================================================================
--- lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/package.html (original)
+++ lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/blocktree/package.html Tue Oct 21 18:15:32 2014
@@ -1,38 +1,26 @@
-<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<!--
- Licensed to the Apache Software Foundation (ASF) under one or more
- contributor license agreements. See the NOTICE file distributed with
- this work for additional information regarding copyright ownership.
- The ASF licenses this file to You under the Apache License, Version 2.0
- (the "License"); you may not use this file except in compliance with
- the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements. See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ -->
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
--->
+<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
</head>
<body>
-BlockTree terms dictionary.
-
-<p>
-This terms dictionary organizes all terms into blocks according to
-shared prefix, such that each block has enough terms, and then stores
-the prefix trie in memory as an FST as the index structure. It allows
-you to plug in your own {@link
-org.apache.lucene.codecs.PostingsBaseFormat} to implement the
-postings.
-</p>
-
-<p>See {@link org.apache.lucene.codecs.blocktree.BlockTreeTermsWriter}
- for the file format.
-</p>
+BlockTree terms dictionary from Lucene 4.0-4.10
</body>
</html>
Modified: lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/lucene40/Lucene40PostingsFormat.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/lucene40/Lucene40PostingsFormat.java?rev=1633429&r1=1633428&r2=1633429&view=diff
==============================================================================
--- lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/lucene40/Lucene40PostingsFormat.java (original)
+++ lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/lucene40/Lucene40PostingsFormat.java Tue Oct 21 18:15:32 2014
@@ -23,7 +23,7 @@ import org.apache.lucene.codecs.FieldsCo
import org.apache.lucene.codecs.FieldsProducer;
import org.apache.lucene.codecs.PostingsFormat;
import org.apache.lucene.codecs.PostingsReaderBase;
-import org.apache.lucene.codecs.blocktree.BlockTreeTermsReader;
+import org.apache.lucene.codecs.blocktree.Lucene40BlockTreeTermsReader;
import org.apache.lucene.index.SegmentReadState;
import org.apache.lucene.index.SegmentWriteState;
@@ -51,7 +51,7 @@ public class Lucene40PostingsFormat exte
boolean success = false;
try {
- FieldsProducer ret = new BlockTreeTermsReader(postings, state);
+ FieldsProducer ret = new Lucene40BlockTreeTermsReader(postings, state);
success = true;
return ret;
} finally {
Modified: lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/lucene41/Lucene41PostingsFormat.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/lucene41/Lucene41PostingsFormat.java?rev=1633429&r1=1633428&r2=1633429&view=diff
==============================================================================
--- lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/lucene41/Lucene41PostingsFormat.java (original)
+++ lucene/dev/branches/lucene5969/lucene/backward-codecs/src/java/org/apache/lucene/codecs/lucene41/Lucene41PostingsFormat.java Tue Oct 21 18:15:32 2014
@@ -23,7 +23,7 @@ import org.apache.lucene.codecs.FieldsCo
import org.apache.lucene.codecs.FieldsProducer;
import org.apache.lucene.codecs.PostingsFormat;
import org.apache.lucene.codecs.PostingsReaderBase;
-import org.apache.lucene.codecs.blocktree.BlockTreeTermsReader;
+import org.apache.lucene.codecs.blocktree.Lucene40BlockTreeTermsReader;
import org.apache.lucene.index.SegmentReadState;
import org.apache.lucene.index.SegmentWriteState;
import org.apache.lucene.util.IOUtils;
@@ -101,7 +101,7 @@ public class Lucene41PostingsFormat exte
state.segmentSuffix);
boolean success = false;
try {
- FieldsProducer ret = new BlockTreeTermsReader(postingsReader, state);
+ FieldsProducer ret = new Lucene40BlockTreeTermsReader(postingsReader, state);
success = true;
return ret;
} finally {
Copied: lucene/dev/branches/lucene5969/lucene/backward-codecs/src/test/org/apache/lucene/codecs/blocktree/TestLucene40BlockFormat.java (from r1633413, lucene/dev/branches/lucene5969/lucene/backward-codecs/src/test/org/apache/lucene/codecs/lucene41/TestLucene41PostingsFormat.java)
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene5969/lucene/backward-codecs/src/test/org/apache/lucene/codecs/blocktree/TestLucene40BlockFormat.java?p2=lucene/dev/branches/lucene5969/lucene/backward-codecs/src/test/org/apache/lucene/codecs/blocktree/TestLucene40BlockFormat.java&p1=lucene/dev/branches/lucene5969/lucene/backward-codecs/src/test/org/apache/lucene/codecs/lucene41/TestLucene41PostingsFormat.java&r1=1633413&r2=1633429&rev=1633429&view=diff
==============================================================================
--- lucene/dev/branches/lucene5969/lucene/backward-codecs/src/test/org/apache/lucene/codecs/lucene41/TestLucene41PostingsFormat.java (original)
+++ lucene/dev/branches/lucene5969/lucene/backward-codecs/src/test/org/apache/lucene/codecs/blocktree/TestLucene40BlockFormat.java Tue Oct 21 18:15:32 2014
@@ -1,4 +1,4 @@
-package org.apache.lucene.codecs.lucene41;
+package org.apache.lucene.codecs.blocktree;
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
@@ -19,8 +19,9 @@ package org.apache.lucene.codecs.lucene4
import org.apache.lucene.analysis.MockAnalyzer;
import org.apache.lucene.codecs.Codec;
-import org.apache.lucene.codecs.blocktree.FieldReader;
-import org.apache.lucene.codecs.blocktree.Stats;
+import org.apache.lucene.codecs.blocktree.Lucene40FieldReader;
+import org.apache.lucene.codecs.blocktree.Lucene40Stats;
+import org.apache.lucene.codecs.lucene41.Lucene41RWCodec;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.BasePostingsFormatTestCase;
@@ -32,7 +33,7 @@ import org.apache.lucene.store.Directory
/**
* Tests BlockPostingsFormat
*/
-public class TestLucene41PostingsFormat extends BasePostingsFormatTestCase {
+public class TestLucene40BlockFormat extends BasePostingsFormatTestCase {
private final Codec codec = new Lucene41RWCodec();
@Override
@@ -54,9 +55,9 @@ public class TestLucene41PostingsFormat
DirectoryReader r = DirectoryReader.open(w, true);
assertEquals(1, r.leaves().size());
- FieldReader field = (FieldReader) r.leaves().get(0).reader().fields().terms("field");
+ Lucene40FieldReader field = (Lucene40FieldReader) r.leaves().get(0).reader().fields().terms("field");
// We should see exactly two blocks: one root block (prefix empty string) and one block for z* terms (prefix z):
- Stats stats = field.computeStats();
+ Lucene40Stats stats = field.computeStats();
assertEquals(0, stats.floorBlockCount);
assertEquals(2, stats.nonFloorBlockCount);
r.close();
Modified: lucene/dev/branches/lucene5969/lucene/backward-codecs/src/test/org/apache/lucene/codecs/lucene40/Lucene40RWPostingsFormat.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene5969/lucene/backward-codecs/src/test/org/apache/lucene/codecs/lucene40/Lucene40RWPostingsFormat.java?rev=1633429&r1=1633428&r2=1633429&view=diff
==============================================================================
--- lucene/dev/branches/lucene5969/lucene/backward-codecs/src/test/org/apache/lucene/codecs/lucene40/Lucene40RWPostingsFormat.java (original)
+++ lucene/dev/branches/lucene5969/lucene/backward-codecs/src/test/org/apache/lucene/codecs/lucene40/Lucene40RWPostingsFormat.java Tue Oct 21 18:15:32 2014
@@ -21,7 +21,7 @@ import java.io.IOException;
import org.apache.lucene.codecs.FieldsConsumer;
import org.apache.lucene.codecs.PostingsWriterBase;
-import org.apache.lucene.codecs.blocktree.BlockTreeTermsWriter;
+import org.apache.lucene.codecs.blocktree.Lucene40BlockTreeTermsWriter;
import org.apache.lucene.index.SegmentWriteState;
/**
@@ -46,7 +46,7 @@ public final class Lucene40RWPostingsFor
// Or... you must make a new Codec for this?
boolean success = false;
try {
- FieldsConsumer ret = new BlockTreeTermsWriter(state, docs, MIN_BLOCK_SIZE, MAX_BLOCK_SIZE);
+ FieldsConsumer ret = new Lucene40BlockTreeTermsWriter(state, docs, MIN_BLOCK_SIZE, MAX_BLOCK_SIZE);
success = true;
return ret;
} finally {
Modified: lucene/dev/branches/lucene5969/lucene/backward-codecs/src/test/org/apache/lucene/codecs/lucene41/Lucene41RWPostingsFormat.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene5969/lucene/backward-codecs/src/test/org/apache/lucene/codecs/lucene41/Lucene41RWPostingsFormat.java?rev=1633429&r1=1633428&r2=1633429&view=diff
==============================================================================
--- lucene/dev/branches/lucene5969/lucene/backward-codecs/src/test/org/apache/lucene/codecs/lucene41/Lucene41RWPostingsFormat.java (original)
+++ lucene/dev/branches/lucene5969/lucene/backward-codecs/src/test/org/apache/lucene/codecs/lucene41/Lucene41RWPostingsFormat.java Tue Oct 21 18:15:32 2014
@@ -21,7 +21,7 @@ import java.io.IOException;
import org.apache.lucene.codecs.FieldsConsumer;
import org.apache.lucene.codecs.PostingsWriterBase;
-import org.apache.lucene.codecs.blocktree.BlockTreeTermsWriter;
+import org.apache.lucene.codecs.blocktree.Lucene40BlockTreeTermsWriter;
import org.apache.lucene.index.SegmentWriteState;
import org.apache.lucene.util.IOUtils;
@@ -41,7 +41,7 @@ public class Lucene41RWPostingsFormat ex
boolean success = false;
try {
- FieldsConsumer ret = new BlockTreeTermsWriter(state,
+ FieldsConsumer ret = new Lucene40BlockTreeTermsWriter(state,
postingsWriter,
MIN_BLOCK_SIZE,
MAX_BLOCK_SIZE);
Modified: lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsReader.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsReader.java?rev=1633429&r1=1633428&r2=1633429&view=diff
==============================================================================
--- lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsReader.java (original)
+++ lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsReader.java Tue Oct 21 18:15:32 2014
@@ -115,9 +115,7 @@ public final class BlockTreeTermsReader
}
// verify
- if (version >= BlockTreeTermsWriter.VERSION_CHECKSUM) {
- CodecUtil.checksumEntireFile(indexIn);
- }
+ CodecUtil.checksumEntireFile(indexIn);
// Have PostingsReader init itself
postingsReader.init(in, state);
@@ -127,9 +125,7 @@ public final class BlockTreeTermsReader
// but for now we at least verify proper structure of the checksum footer: which looks
// for FOOTER_MAGIC + algorithmID. This is cheap and can detect some forms of corruption
// such as file truncation.
- if (version >= BlockTreeTermsWriter.VERSION_CHECKSUM) {
- CodecUtil.retrieveChecksum(in);
- }
+ CodecUtil.retrieveChecksum(in);
// Read per-field details
seekDir(in, dirOffset);
@@ -160,17 +156,12 @@ public final class BlockTreeTermsReader
final long sumTotalTermFreq = fieldInfo.getIndexOptions() == IndexOptions.DOCS_ONLY ? -1 : in.readVLong();
final long sumDocFreq = in.readVLong();
final int docCount = in.readVInt();
- final int longsSize = version >= BlockTreeTermsWriter.VERSION_META_ARRAY ? in.readVInt() : 0;
+ final int longsSize = in.readVInt();
if (longsSize < 0) {
throw new CorruptIndexException("invalid longsSize for field: " + fieldInfo.name + ", longsSize=" + longsSize, in);
}
- BytesRef minTerm, maxTerm;
- if (version >= BlockTreeTermsWriter.VERSION_MIN_MAX_TERMS) {
- minTerm = readBytesRef(in);
- maxTerm = readBytesRef(in);
- } else {
- minTerm = maxTerm = null;
- }
+ BytesRef minTerm = readBytesRef(in);
+ BytesRef maxTerm = readBytesRef(in);
if (docCount < 0 || docCount > state.segmentInfo.getDocCount()) { // #docs with field must be <= #docs
throw new CorruptIndexException("invalid docCount: " + docCount + " maxDoc: " + state.segmentInfo.getDocCount(), in);
}
@@ -212,9 +203,6 @@ public final class BlockTreeTermsReader
int version = CodecUtil.checkHeader(input, BlockTreeTermsWriter.TERMS_CODEC_NAME,
BlockTreeTermsWriter.VERSION_START,
BlockTreeTermsWriter.VERSION_CURRENT);
- if (version < BlockTreeTermsWriter.VERSION_APPEND_ONLY) {
- dirOffset = input.readLong();
- }
return version;
}
@@ -223,22 +211,14 @@ public final class BlockTreeTermsReader
int version = CodecUtil.checkHeader(input, BlockTreeTermsWriter.TERMS_INDEX_CODEC_NAME,
BlockTreeTermsWriter.VERSION_START,
BlockTreeTermsWriter.VERSION_CURRENT);
- if (version < BlockTreeTermsWriter.VERSION_APPEND_ONLY) {
- indexDirOffset = input.readLong();
- }
return version;
}
/** Seek {@code input} to the directory offset. */
private void seekDir(IndexInput input, long dirOffset)
throws IOException {
- if (version >= BlockTreeTermsWriter.VERSION_CHECKSUM) {
- input.seek(input.length() - CodecUtil.footerLength() - 8);
- dirOffset = input.readLong();
- } else if (version >= BlockTreeTermsWriter.VERSION_APPEND_ONLY) {
- input.seek(input.length() - 8);
- dirOffset = input.readLong();
- }
+ input.seek(input.length() - CodecUtil.footerLength() - 8);
+ dirOffset = input.readLong();
input.seek(dirOffset);
}
@@ -308,14 +288,12 @@ public final class BlockTreeTermsReader
}
@Override
- public void checkIntegrity() throws IOException {
- if (version >= BlockTreeTermsWriter.VERSION_CHECKSUM) {
- // term dictionary
- CodecUtil.checksumEntireFile(in);
+ public void checkIntegrity() throws IOException {
+ // term dictionary
+ CodecUtil.checksumEntireFile(in);
- // postings
- postingsReader.checkIntegrity();
- }
+ // postings
+ postingsReader.checkIntegrity();
}
@Override
Modified: lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsWriter.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsWriter.java?rev=1633429&r1=1633428&r2=1633429&view=diff
==============================================================================
--- lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsWriter.java (original)
+++ lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/codecs/blocktree/BlockTreeTermsWriter.java Tue Oct 21 18:15:32 2014
@@ -220,21 +220,9 @@ public final class BlockTreeTermsWriter
/** Initial terms format. */
public static final int VERSION_START = 0;
-
- /** Append-only */
- public static final int VERSION_APPEND_ONLY = 1;
-
- /** Meta data as array */
- public static final int VERSION_META_ARRAY = 2;
-
- /** checksums */
- public static final int VERSION_CHECKSUM = 3;
-
- /** min/max term */
- public static final int VERSION_MIN_MAX_TERMS = 4;
/** Current terms format. */
- public static final int VERSION_CURRENT = VERSION_MIN_MAX_TERMS;
+ public static final int VERSION_CURRENT = VERSION_START;
/** Extension of terms index file */
static final String TERMS_INDEX_EXTENSION = "tip";
Modified: lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/index/CheckIndex.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/index/CheckIndex.java?rev=1633429&r1=1633428&r2=1633429&view=diff
==============================================================================
--- lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/index/CheckIndex.java (original)
+++ lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/index/CheckIndex.java Tue Oct 21 18:15:32 2014
@@ -278,7 +278,7 @@ public class CheckIndex implements Close
* tree terms dictionary (this is only set if the
* {@link PostingsFormat} for this segment uses block
* tree. */
- public Map<String,Stats> blockTreeStats = null;
+ public Map<String,Object> blockTreeStats = null;
}
/**
@@ -1289,14 +1289,12 @@ public class CheckIndex implements Close
// docs got deleted and then merged away):
} else {
- if (fieldTerms instanceof FieldReader) {
- final Stats stats = ((FieldReader) fieldTerms).computeStats();
- assert stats != null;
- if (status.blockTreeStats == null) {
- status.blockTreeStats = new HashMap<>();
- }
- status.blockTreeStats.put(field, stats);
+ final Object stats = fieldTerms.getStats();
+ assert stats != null;
+ if (status.blockTreeStats == null) {
+ status.blockTreeStats = new HashMap<>();
}
+ status.blockTreeStats.put(field, stats);
if (sumTotalTermFreq != 0) {
final long v = fields.terms(field).getSumTotalTermFreq();
@@ -1423,7 +1421,7 @@ public class CheckIndex implements Close
}
if (verbose && status.blockTreeStats != null && infoStream != null && status.termCount > 0) {
- for(Map.Entry<String,Stats> ent : status.blockTreeStats.entrySet()) {
+ for(Map.Entry<String, Object> ent : status.blockTreeStats.entrySet()) {
infoStream.println(" field \"" + ent.getKey() + "\":");
infoStream.println(" " + ent.getValue().toString().replace("\n", "\n "));
}
Modified: lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/index/Terms.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/index/Terms.java?rev=1633429&r1=1633428&r2=1633429&view=diff
==============================================================================
--- lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/index/Terms.java (original)
+++ lucene/dev/branches/lucene5969/lucene/core/src/java/org/apache/lucene/index/Terms.java Tue Oct 21 18:15:32 2014
@@ -193,4 +193,9 @@ public abstract class Terms {
scratch.grow(scratch.length());
}
}
+
+ public String getStats() {
+ // nocommit: add a meaningful default
+ return "";
+ }
}