func (r *BlockTreeTermsReader) readIndexHeader(input store.IndexInput) (version int, err error) {
version, err = asInt(codec.CheckHeader(input, BTT_INDEX_CODEC_NAME, BTT_INDEX_VERSION_START, BTT_INDEX_VERSION_CURRENT))
if err != nil {
return version, err
}
if version < BTT_INDEX_VERSION_APPEND_ONLY {
r.indexDirOffset, err = input.ReadLong()
if err != nil {
return version, err
}
}
return version, nil
}
func (r *Lucene41PostingsReader) Init(termsIn store.IndexInput) error {
log.Printf("Initializing from: %v", termsIn)
// Make sure we are talking to the matching postings writer
_, err := codec.CheckHeader(termsIn, LUCENE41_TERMS_CODEC, LUCENE41_VERSION_START, LUCENE41_VERSION_CURRENT)
if err != nil {
return err
}
indexBlockSize, err := termsIn.ReadVInt()
if err != nil {
return err
}
log.Printf("Index block size: %v", indexBlockSize)
if indexBlockSize != LUCENE41_BLOCK_SIZE {
panic(fmt.Sprintf("index-time BLOCK_SIZE (%v) != read-time BLOCK_SIZE (%v)", indexBlockSize, LUCENE41_BLOCK_SIZE))
}
return nil
}
func (r *BlockTreeTermsReader) seekDir(input store.IndexInput, dirOffset int64) (err error) {
log.Printf("Seeking to: %v", dirOffset)
if r.version >= BTT_INDEX_VERSION_APPEND_ONLY {
input.Seek(input.Length() - 8)
if dirOffset, err = input.ReadLong(); err != nil {
return err
}
}
input.Seek(dirOffset)
return nil
}
func newFieldReader(owner *BlockTreeTermsReader,
fieldInfo FieldInfo, numTerms int64, rootCode []byte,
sumTotalTermFreq, sumDocFreq int64, docCount int32, indexStartFP int64,
indexIn store.IndexInput) (r FieldReader, err error) {
log.Print("Initializing FieldReader...")
if numTerms <= 0 {
panic("assert fail")
}
// assert numTerms > 0
r = FieldReader{
BlockTreeTermsReader: owner,
fieldInfo: fieldInfo,
numTerms: numTerms,
sumTotalTermFreq: sumTotalTermFreq,
sumDocFreq: sumDocFreq,
docCount: docCount,
indexStartFP: indexStartFP,
rootCode: rootCode,
}
log.Printf("BTTR: seg=%v field=%v rootBlockCode=%v divisor=",
owner.segment, fieldInfo.name, rootCode)
in := store.NewByteArrayDataInput(rootCode)
n, err := in.ReadVLong()
if err != nil {
return r, err
}
r.rootBlockFP = int64(uint64(n) >> BTT_OUTPUT_FLAGS_NUM_BITS)
if indexIn != nil {
clone := indexIn.Clone()
log.Printf("start=%v field=%v", indexStartFP, fieldInfo.name)
clone.Seek(indexStartFP)
r.index, err = util.LoadFST(clone, util.ByteSequenceOutputsSingleton())
}
return r, err
}
/* Reads but does not decode the byte[] blob holding
metadata for the current terms block */
func (r *Lucene41PostingsReader) ReadTermsBlock(termsIn store.IndexInput, fieldInfo FieldInfo, _termState *BlockTermState) (err error) {
termState := _termState.Self.(*intBlockTermState)
numBytes, err := asInt(termsIn.ReadVInt())
if err != nil {
return err
}
if termState.bytes == nil {
// TODO over-allocate
termState.bytes = make([]byte, numBytes)
termState.bytesReader = store.NewEmptyByteArrayDataInput()
} else if len(termState.bytes) < numBytes {
// TODO over-allocate
termState.bytes = make([]byte, numBytes)
}
err = termsIn.ReadBytes(termState.bytes)
if err != nil {
return err
}
termState.bytesReader.Reset(termState.bytes)
return nil
}
func newCompressingStoredFieldsIndexReader(fieldsIndexIn store.IndexInput, si SegmentInfo) (r *CompressingStoredFieldsIndexReader, err error) {
r = &CompressingStoredFieldsIndexReader{}
r.maxDoc = int(si.docCount)
r.docBases = make([]int, 0, 16)
r.startPointers = make([]int64, 0, 16)
r.avgChunkDocs = make([]int, 0, 16)
r.avgChunkSizes = make([]int64, 0, 16)
r.docBasesDeltas = make([]util.PackedIntsReader, 0, 16)
r.startPointersDeltas = make([]util.PackedIntsReader, 0, 16)
packedIntsVersion, err := fieldsIndexIn.ReadVInt()
if err != nil {
return nil, err
}
for blockCount := 0; ; blockCount++ {
numChunks, err := fieldsIndexIn.ReadVInt()
if err != nil {
return nil, err
}
if numChunks == 0 {
break
}
{ // doc bases
n, err := fieldsIndexIn.ReadVInt()
if err != nil {
return nil, err
}
r.docBases = append(r.docBases, int(n))
n, err = fieldsIndexIn.ReadVInt()
if err != nil {
return nil, err
}
r.avgChunkDocs = append(r.avgChunkDocs, int(n))
bitsPerDocBase, err := fieldsIndexIn.ReadVInt()
if err != nil {
return nil, err
}
if bitsPerDocBase > 32 {
return nil, errors.New(fmt.Sprintf("Corrupted bitsPerDocBase (resource=%v)", fieldsIndexIn))
}
pr, err := util.NewPackedReaderNoHeader(fieldsIndexIn, util.PACKED, packedIntsVersion, numChunks, uint32(bitsPerDocBase))
if err != nil {
return nil, err
}
r.docBasesDeltas = append(r.docBasesDeltas, pr)
}
{ // start pointers
n, err := fieldsIndexIn.ReadVLong()
if err != nil {
return nil, err
}
r.startPointers = append(r.startPointers, n)
n, err = fieldsIndexIn.ReadVLong()
if err != nil {
return nil, err
}
r.avgChunkSizes = append(r.avgChunkSizes, n)
bitsPerStartPointer, err := fieldsIndexIn.ReadVInt()
if err != nil {
return nil, err
}
if bitsPerStartPointer > 64 {
return nil, errors.New(fmt.Sprintf("Corrupted bitsPerStartPonter (resource=%v)", fieldsIndexIn))
}
pr, err := util.NewPackedReaderNoHeader(fieldsIndexIn, util.PACKED, packedIntsVersion, numChunks, uint32(bitsPerStartPointer))
if err != nil {
return nil, err
}
r.startPointersDeltas = append(r.startPointersDeltas, pr)
}
}
return r, nil
}
// CompressingStoredFieldsReader.java L90
func newCompressingStoredFieldsReader(d store.Directory, si SegmentInfo, segmentSuffix string, fn FieldInfos,
ctx store.IOContext, formatName string, compressionMode codec.CompressionMode) (r *CompressingStoredFieldsReader, err error) {
r = &CompressingStoredFieldsReader{}
r.compressionMode = compressionMode
segment := si.name
r.fieldInfos = fn
r.numDocs = int(si.docCount)
var indexStream store.IndexInput
success := false
defer func() {
if !success {
log.Println("Failed to initialize CompressionStoredFieldsReader.")
if err != nil {
log.Print(err)
}
util.Close(r, indexStream)
}
}()
// Load the index into memory
indexStreamFN := util.SegmentFileName(segment, segmentSuffix, LUCENE40_SF_FIELDS_INDEX_EXTENSION)
indexStream, err = d.OpenInput(indexStreamFN, ctx)
if err != nil {
return nil, err
}
codecNameIdx := formatName + CODEC_SFX_IDX
codec.CheckHeader(indexStream, codecNameIdx, CODEC_SFX_VERSION_START, CODEC_SFX_VERSION_CURRENT)
if int64(codec.HeaderLength(codecNameIdx)) != indexStream.FilePointer() {
panic("assert fail")
}
r.indexReader, err = newCompressingStoredFieldsIndexReader(indexStream, si)
if err != nil {
return nil, err
}
err = indexStream.Close()
if err != nil {
return nil, err
}
indexStream = nil
// Open the data file and read metadata
fieldsStreamFN := util.SegmentFileName(segment, segmentSuffix, LUCENE40_SF_FIELDS_EXTENSION)
r.fieldsStream, err = d.OpenInput(fieldsStreamFN, ctx)
if err != nil {
return nil, err
}
codecNameDat := formatName + CODEC_SFX_DAT
codec.CheckHeader(r.fieldsStream, codecNameDat, CODEC_SFX_VERSION_START, CODEC_SFX_VERSION_CURRENT)
if int64(codec.HeaderLength(codecNameDat)) != r.fieldsStream.FilePointer() {
panic("assert fail")
}
n, err := r.fieldsStream.ReadVInt()
if err != nil {
return nil, err
}
r.packedIntsVersion = int(n)
r.decompressor = compressionMode.NewDecompressor()
r.bytes = make([]byte, 0)
success = true
return r, nil
}
func newBlockTreeTermsReader(dir store.Directory, fieldInfos FieldInfos, info SegmentInfo,
postingsReader PostingsReaderBase, ctx store.IOContext,
segmentSuffix string, indexDivisor int) (p FieldsProducer, err error) {
log.Print("Initializing BlockTreeTermsReader...")
fp := &BlockTreeTermsReader{
postingsReader: postingsReader,
fields: make(map[string]FieldReader),
segment: info.name,
}
fp.in, err = dir.OpenInput(util.SegmentFileName(info.name, segmentSuffix, BTT_EXTENSION), ctx)
if err != nil {
return fp, err
}
success := false
var indexIn store.IndexInput
defer func() {
if !success {
log.Print("Failed to initialize BlockTreeTermsReader.")
if err != nil {
log.Print("DEBUG ", err)
}
// this.close() will close in:
util.CloseWhileSuppressingError(indexIn, fp)
}
}()
fp.version, err = fp.readHeader(fp.in)
if err != nil {
return fp, err
}
log.Printf("Version: %v", fp.version)
if indexDivisor != -1 {
indexIn, err = dir.OpenInput(util.SegmentFileName(info.name, segmentSuffix, BTT_INDEX_EXTENSION), ctx)
if err != nil {
return fp, err
}
indexVersion, err := fp.readIndexHeader(indexIn)
if err != nil {
return fp, err
}
log.Printf("Index version: %v", indexVersion)
if int(indexVersion) != fp.version {
return fp, errors.New(fmt.Sprintf("mixmatched version files: %v=%v,%v=%v", fp.in, fp.version, indexIn, indexVersion))
}
}
// Have PostingsReader init itself
postingsReader.Init(fp.in)
// Read per-field details
fp.seekDir(fp.in, fp.dirOffset)
if indexDivisor != -1 {
fp.seekDir(indexIn, fp.indexDirOffset)
}
numFields, err := fp.in.ReadVInt()
if err != nil {
return fp, err
}
log.Printf("Fields number: %v", numFields)
if numFields < 0 {
return fp, errors.New(fmt.Sprintf("invalid numFields: %v (resource=%v)", numFields, fp.in))
}
for i := int32(0); i < numFields; i++ {
log.Printf("Next field...")
field, err := fp.in.ReadVInt()
if err != nil {
return fp, err
}
log.Printf("Field: %v", field)
numTerms, err := fp.in.ReadVLong()
if err != nil {
return fp, err
}
// assert numTerms >= 0
log.Printf("Terms number: %v", numTerms)
numBytes, err := fp.in.ReadVInt()
if err != nil {
return fp, err
}
log.Printf("Bytes number: %v", numBytes)
rootCode := make([]byte, numBytes)
err = fp.in.ReadBytes(rootCode)
if err != nil {
return fp, err
}
fieldInfo := fieldInfos.byNumber[field]
// assert fieldInfo != nil
var sumTotalTermFreq int64
if fieldInfo.indexOptions == INDEX_OPT_DOCS_ONLY {
sumTotalTermFreq = -1
} else {
sumTotalTermFreq, err = fp.in.ReadVLong()
if err != nil {
return fp, err
}
}
sumDocFreq, err := fp.in.ReadVLong()
if err != nil {
return fp, err
}
docCount, err := fp.in.ReadVInt()
if err != nil {
return fp, err
}
log.Printf("DocCount: %v", docCount)
if docCount < 0 || docCount > info.docCount { // #docs with field must be <= #docs
return fp, errors.New(fmt.Sprintf(
"invalid docCount: %v maxDoc: %v (resource=%v)",
docCount, info.docCount, fp.in))
}
if sumDocFreq < int64(docCount) { // #postings must be >= #docs with field
return fp, errors.New(fmt.Sprintf(
"invalid sumDocFreq: %v docCount: %v (resource=%v)",
sumDocFreq, docCount, fp.in))
}
if sumTotalTermFreq != -1 && sumTotalTermFreq < sumDocFreq { // #positions must be >= #postings
return fp, errors.New(fmt.Sprintf(
"invalid sumTotalTermFreq: %v sumDocFreq: %v (resource=%v)",
sumTotalTermFreq, sumDocFreq, fp.in))
}
var indexStartFP int64
if indexDivisor != -1 {
indexStartFP, err = indexIn.ReadVLong()
if err != nil {
return fp, err
}
}
log.Printf("indexStartFP: %v", indexStartFP)
if _, ok := fp.fields[fieldInfo.name]; ok {
return fp, errors.New(fmt.Sprintf(
"duplicate field: %v (resource=%v)", fieldInfo.name, fp.in))
}
fp.fields[fieldInfo.name], err = newFieldReader(fp,
fieldInfo, numTerms, rootCode, sumTotalTermFreq,
sumDocFreq, docCount, indexStartFP, indexIn)
if err != nil {
return fp, err
}
log.Print("DEBUG field processed.")
}
if indexDivisor != -1 {
err = indexIn.Close()
if err != nil {
return fp, err
}
}
success = true
return fp, nil
}
/*
Lucene42DocValuesProducer.java
Line 126
*/
func (dvp *Lucene42DocValuesProducer) readFields(meta store.IndexInput, infos FieldInfos) (err error) {
fieldNumber, err := meta.ReadVInt()
for fieldNumber != -1 && err == nil {
fieldType, err := meta.ReadByte()
if err != nil {
break
}
switch fieldType {
case LUCENE42_DV_NUMBER:
entry := NumericEntry{}
entry.offset, err = meta.ReadLong()
if err != nil {
return err
}
entry.format, err = meta.ReadByte()
if err != nil {
return err
}
switch entry.format {
case LUCENE42_DV_DELTA_COMPRESSED:
case LUCENE42_DV_TABLE_COMPRESSED:
case LUCENE42_DV_GCD_COMPRESSED:
case LUCENE42_DV_UNCOMPRESSED:
default:
return errors.New(fmt.Sprintf("Unknown format: %v, input=%v", entry.format, meta))
}
if entry.format != LUCENE42_DV_UNCOMPRESSED {
n, err := meta.ReadVInt()
if err != nil {
return err
}
entry.packedIntsVersion = int(n)
}
case LUCENE42_DV_BYTES:
panic("not implemented yet")
case LUCENE42_DV_FST:
panic("not implemented yet")
default:
return errors.New(fmt.Sprintf("invalid entry type: %v, input=%v", fieldType, meta))
}
fieldNumber, err = meta.ReadVInt()
}
return err
}
