internal virtual void SeekEnum(SegmentTermEnum enumerator, int indexOffset)
        {
            PagedBytesDataInput input = (PagedBytesDataInput)dataInput.Clone();

            input.SetPosition(indexToDataOffset.Get(indexOffset));

            // read the term
            int  fieldId = input.ReadVInt32();
            Term field   = fields[fieldId];
            Term term    = new Term(field.Field, input.ReadString());

            // read the terminfo
            var termInfo = new TermInfo();

            termInfo.DocFreq = input.ReadVInt32();
            if (termInfo.DocFreq >= skipInterval)
            {
                termInfo.SkipOffset = input.ReadVInt32();
            }
            else
            {
                termInfo.SkipOffset = 0;
            }
            termInfo.FreqPointer = input.ReadVInt64();
            termInfo.ProxPointer = input.ReadVInt64();

            long pointer = input.ReadVInt64();

            // perform the seek
            enumerator.Seek(pointer, ((long)indexOffset * totalIndexInterval) - 1, term, termInfo);
        }
        /// <summary>
        /// Binary search for the given term.
        /// </summary>
        /// <param name="term">
        ///          The term to locate. </param>
        /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
        internal virtual int GetIndexOffset(Term term)
        {
            int lo = 0;
            int hi = indexSize - 1;
            PagedBytesDataInput input   = (PagedBytesDataInput)dataInput.Clone();
            BytesRef            scratch = new BytesRef();

            while (hi >= lo)
            {
                int mid   = (int)((uint)(lo + hi) >> 1);
                int delta = CompareTo(term, mid, input, scratch);
                if (delta < 0)
                {
                    hi = mid - 1;
                }
                else if (delta > 0)
                {
                    lo = mid + 1;
                }
                else
                {
                    return(mid);
                }
            }
            return(hi);
        }
Exemple #3
0
            public override object Clone()
            {
                PagedBytesDataInput clone = outerInstance.GetDataInput();

                clone.SetPosition(GetPosition());
                return(clone);
            }
Exemple #4
0
            public override object Clone()
            {
                PagedBytesDataInput clone = OuterInstance.DataInput;

                clone.Position = Position;
                return(clone);
            }
        /// <summary>
        /// Loads the segment information at segment load time.
        /// </summary>
        /// <param name="indexEnum">
        ///          The term enum. </param>
        /// <param name="indexDivisor">
        ///          The index divisor. </param>
        /// <param name="tiiFileLength">
        ///          The size of the tii file, used to approximate the size of the
        ///          buffer. </param>
        /// <param name="totalIndexInterval">
        ///          The total index interval. </param>
        public TermInfosReaderIndex(SegmentTermEnum indexEnum, int indexDivisor, long tiiFileLength, int totalIndexInterval)
        {
            this.totalIndexInterval = totalIndexInterval;
            indexSize    = 1 + ((int)indexEnum.size - 1) / indexDivisor;
            skipInterval = indexEnum.skipInterval;
            // this is only an inital size, it will be GCed once the build is complete
            long                 initialSize    = (long)(tiiFileLength * 1.5) / indexDivisor;
            PagedBytes           dataPagedBytes = new PagedBytes(EstimatePageBits(initialSize));
            PagedBytesDataOutput dataOutput     = dataPagedBytes.GetDataOutput();

            int            bitEstimate  = 1 + MathUtil.Log(tiiFileLength, 2);
            GrowableWriter indexToTerms = new GrowableWriter(bitEstimate, indexSize, PackedInt32s.DEFAULT);

            string         currentField = null;
            IList <string> fieldStrs    = new List <string>();
            int            fieldCounter = -1;

            for (int i = 0; indexEnum.Next(); i++)
            {
                Term term = indexEnum.Term();
                if (currentField == null || !currentField.Equals(term.Field, StringComparison.Ordinal))
                {
                    currentField = term.Field;
                    fieldStrs.Add(currentField);
                    fieldCounter++;
                }
                TermInfo termInfo = indexEnum.TermInfo();
                indexToTerms.Set(i, dataOutput.GetPosition());
                dataOutput.WriteVInt32(fieldCounter);
                dataOutput.WriteString(term.Text());
                dataOutput.WriteVInt32(termInfo.DocFreq);
                if (termInfo.DocFreq >= skipInterval)
                {
                    dataOutput.WriteVInt32(termInfo.SkipOffset);
                }
                dataOutput.WriteVInt64(termInfo.FreqPointer);
                dataOutput.WriteVInt64(termInfo.ProxPointer);
                dataOutput.WriteVInt64(indexEnum.indexPointer);
                for (int j = 1; j < indexDivisor; j++)
                {
                    if (!indexEnum.Next())
                    {
                        break;
                    }
                }
            }

            fields = new Term[fieldStrs.Count];
            for (int i = 0; i < fields.Length; i++)
            {
                fields[i] = new Term(fieldStrs[i]);
            }

            dataPagedBytes.Freeze(true);
            dataInput         = dataPagedBytes.GetDataInput();
            indexToDataOffset = indexToTerms.Mutable;

            ramBytesUsed = fields.Length * (RamUsageEstimator.NUM_BYTES_OBJECT_REF + RamUsageEstimator.ShallowSizeOfInstance(typeof(Term))) + dataPagedBytes.RamBytesUsed() + indexToDataOffset.RamBytesUsed();
        }
        /// <summary>
        /// Gets the term at the given position.  For testing.
        /// </summary>
        /// <param name="termIndex">
        ///          The position to read the term from the index. </param>
        /// <returns> The term. </returns>
        /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
        internal virtual Term GetTerm(int termIndex)
        {
            PagedBytesDataInput input = (PagedBytesDataInput)dataInput.Clone();

            input.SetPosition(indexToDataOffset.Get(termIndex));

            // read the term
            int  fieldId = input.ReadVInt32();
            Term field   = fields[fieldId];

            return(new Term(field.Field, input.ReadString()));
        }
        /// <summary>
        /// Gets the term at the given position.  For testing.
        /// </summary>
        /// <param name="termIndex">
        ///          the position to read the term from the index. </param>
        /// <returns> the term. </returns>
        /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
        public virtual Term GetTerm(int termIndex)
        {
            PagedBytesDataInput input = (PagedBytesDataInput)DataInput.Clone();

            input.Position = IndexToDataOffset.Get(termIndex);

            // read the term
            int  fieldId = input.ReadVInt();
            Term field   = Fields[fieldId];

            return(new Term(field.Field, input.ReadString()));
        }
        /// <summary>
        /// Compare the fields of the terms first, and if not equals return from
        /// compare. If equal compare terms.
        /// </summary>
        /// <param name="term">
        ///          The term to compare. </param>
        /// <param name="termIndex">
        ///          The position of the term in the input to compare </param>
        /// <param name="input">
        ///          The input buffer. </param>
        /// <returns> int. </returns>
        /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
        private int CompareTo(Term term, int termIndex, PagedBytesDataInput input, BytesRef reuse)
        {
            // if term field does not equal mid's field index, then compare fields
            // else if they are equal, compare term's string values...
            int c = CompareField(term, termIndex, input);

            if (c == 0)
            {
                reuse.Length = input.ReadVInt32();
                reuse.Grow(reuse.Length);
                input.ReadBytes(reuse.Bytes, 0, reuse.Length);
                return(comparer.Compare(term.Bytes, reuse));
            }
            return(c);
        }
 /// <summary>
 /// Compares the fields before checking the text of the terms.
 /// </summary>
 /// <param name="term">
 ///          The given term. </param>
 /// <param name="termIndex">
 ///          The term that exists in the data block. </param>
 /// <param name="input">
 ///          The data block. </param>
 /// <returns> int. </returns>
 /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
 private int CompareField(Term term, int termIndex, PagedBytesDataInput input)
 {
     input.SetPosition(indexToDataOffset.Get(termIndex));
     return(term.Field.CompareToOrdinal(fields[input.ReadVInt32()].Field));
 }
 /// <summary>
 /// Compares the fields before checking the text of the terms.
 /// </summary>
 /// <param name="term">
 ///          the given term. </param>
 /// <param name="termIndex">
 ///          the term that exists in the data block. </param>
 /// <param name="input">
 ///          the data block. </param>
 /// <returns> int. </returns>
 /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
 private int CompareField(Term term, int termIndex, PagedBytesDataInput input)
 {
     input.Position = IndexToDataOffset.Get(termIndex);
     return(System.String.Compare(term.Field, Fields[input.ReadVInt()].Field, System.StringComparison.Ordinal));
 }
 /// <summary>
 /// Compares the fields before checking the text of the terms.
 /// </summary>
 /// <param name="term">
 ///          the given term. </param>
 /// <param name="termIndex">
 ///          the term that exists in the data block. </param>
 /// <param name="input">
 ///          the data block. </param>
 /// <returns> int. </returns>
 /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
 private int CompareField(Term term, int termIndex, PagedBytesDataInput input)
 {
     input.Position = IndexToDataOffset.Get(termIndex);
     return(term.Field().CompareTo(Fields[input.ReadVInt()].Field()));
 }