lucene46

Documentation

Index

• Constants
• Variables
• type Lucene46FieldInfosFormat
  • func NewLucene46FieldInfosFormat() *Lucene46FieldInfosFormat
  • func (f *Lucene46FieldInfosFormat) FieldInfosReader() FieldInfosReader
  • func (f *Lucene46FieldInfosFormat) FieldInfosWriter() FieldInfosWriter
• type Lucene46SegmentInfoFormat
  • func NewLucene46SegmentInfoFormat() *Lucene46SegmentInfoFormat
  • func (f *Lucene46SegmentInfoFormat) Read(dir store.Directory, segName string, ctx store.IOContext) (si *SegmentInfo, err error)
  • func (f *Lucene46SegmentInfoFormat) SegmentInfoReader() SegmentInfoReader
  • func (f *Lucene46SegmentInfoFormat) SegmentInfoWriter() SegmentInfoWriter
  • func (f *Lucene46SegmentInfoFormat) Write(dir store.Directory, si *SegmentInfo, fis FieldInfos, ctx store.IOContext) error

Constants

const (
	/* Extension of field info */
	FI_EXTENSION = "fnm"

	/* Codec header */
	FI_CODEC_NAME            = "Lucene46FieldInfos"
	FI_FORMAT_START          = 0
	FI_FORMAT_CHECKSUM       = 1
	FI_FORMAT_SORTED_NUMERIC = 2
	FI_FORMAT_CURRENT        = FI_FORMAT_SORTED_NUMERIC

	// Field flags
	FI_IS_INDEXED                   = 0x1
	FI_STORE_TERMVECTOR             = 0x2
	FI_STORE_OFFSETS_IN_POSTINGS    = 0x4
	FI_OMIT_NORMS                   = 0x10
	FI_STORE_PAYLOADS               = 0x20
	FI_OMIT_TERM_FREQ_AND_POSITIONS = 0x40
	FI_OMIT_POSITIONS               = 0x80
)

const (
	// File extension used to store SegmentInfo.
	SI_EXTENSION        = "si"
	SI_CODEC_NAME       = "Lucene46SegmentInfo"
	SI_VERSION_START    = 0
	SI_VERSION_CHECKSUM = 1
	SI_VERSION_CURRENT  = SI_VERSION_CHECKSUM
)

Variables

var Lucene46FieldInfosReader = func(dir store.Directory,
	segment, suffix string, ctx store.IOContext) (fis FieldInfos, err error) {

	filename := util.SegmentFileName(segment, suffix, FI_EXTENSION)
	var input store.ChecksumIndexInput
	if input, err = dir.OpenChecksumInput(filename, ctx); err != nil {
		return
	}

	var success = false
	defer func() {
		if success {
			err = input.Close()
		} else {
			util.CloseWhileSuppressingError(input)
		}
	}()

	var codecVersion int
	if codecVersion, err = asInt(codec.CheckHeader(input, FI_CODEC_NAME, FI_FORMAT_START, FI_FORMAT_CURRENT)); err != nil {
		return
	}

	var size int
	if size, err = asInt(input.ReadVInt()); err != nil {
		return
	}

	var infos []*FieldInfo
	var name string
	var fieldNumber int32
	var bits, val byte
	var isIndexed, storeTermVector, omitNorms, storePayloads bool
	var indexOptions IndexOptions
	var docValuesType, normsType DocValuesType
	var dvGen int64
	var attributes map[string]string
	for i := 0; i < size; i++ {
		if name, err = input.ReadString(); err != nil {
			return
		}
		if fieldNumber, err = input.ReadVInt(); err != nil {
			return
		}
		assert2(fieldNumber >= 0,
			"invalid field number for field: %v, fieldNumber=%v (resource=%v)",
			name, fieldNumber, input)
		if bits, err = input.ReadByte(); err != nil {
			return
		}
		isIndexed = (bits & FI_IS_INDEXED) != 0
		storeTermVector = (bits & FI_STORE_TERMVECTOR) != 0
		omitNorms = (bits & FI_OMIT_NORMS) != 0
		storePayloads = (bits & FI_STORE_PAYLOADS) != 0
		switch {
		case !isIndexed:

		case (bits & FI_OMIT_TERM_FREQ_AND_POSITIONS) != 0:
			indexOptions = INDEX_OPT_DOCS_ONLY
		case (bits & FI_OMIT_POSITIONS) != 0:
			indexOptions = INDEX_OPT_DOCS_AND_FREQS
		case (bits & FI_STORE_OFFSETS_IN_POSTINGS) != 0:
			indexOptions = INDEX_OPT_DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS
		default:
			indexOptions = INDEX_OPT_DOCS_AND_FREQS_AND_POSITIONS
		}

		if val, err = input.ReadByte(); err != nil {
			return
		}
		if docValuesType, err = getDocValuesType(input, val&0x0F); err != nil {
			return
		}
		if normsType, err = getDocValuesType(input, (val>>4)&0x0F); err != nil {
			return
		}
		if dvGen, err = input.ReadLong(); err != nil {
			return
		}
		if attributes, err = input.ReadStringStringMap(); err != nil {
			return
		}
		infos = append(infos, NewFieldInfo(name, isIndexed, fieldNumber,
			storeTermVector, omitNorms, storePayloads, indexOptions,
			docValuesType, normsType, dvGen, attributes))
	}

	if codecVersion >= FI_FORMAT_CHECKSUM {
		if _, err = codec.CheckFooter(input); err != nil {
			return
		}
	} else {
		if err = codec.CheckEOF(input); err != nil {
			return
		}
	}
	fis = NewFieldInfos(infos)
	success = true
	return fis, nil
}

var Lucene46FieldInfosWriter = func(dir store.Directory,
	segName, suffix string, infos FieldInfos, ctx store.IOContext) (err error) {

	filename := util.SegmentFileName(segName, suffix, FI_EXTENSION)
	var output store.IndexOutput
	if output, err = dir.CreateOutput(filename, ctx); err != nil {
		return
	}

	var success = false
	defer func() {
		if success {
			err = output.Close()
		} else {
			util.CloseWhileSuppressingError(output)
		}
	}()

	if err = codec.WriteHeader(output, FI_CODEC_NAME, FI_FORMAT_CURRENT); err != nil {
		return
	}
	if err = output.WriteVInt(int32(infos.Size())); err != nil {
		return
	}
	for _, fi := range infos.Values {
		indexOptions := fi.IndexOptions()
		bits := byte(0)
		if fi.HasVectors() {
			bits |= FI_STORE_TERMVECTOR
		}
		if fi.OmitsNorms() {
			bits |= FI_OMIT_NORMS
		}
		if fi.HasPayloads() {
			bits |= FI_STORE_PAYLOADS
		}
		if fi.IsIndexed() {
			bits |= FI_IS_INDEXED
			assert(indexOptions >= INDEX_OPT_DOCS_AND_FREQS_AND_POSITIONS || !fi.HasPayloads())
			switch indexOptions {
			case INDEX_OPT_DOCS_ONLY:
				bits |= FI_OMIT_TERM_FREQ_AND_POSITIONS
			case INDEX_OPT_DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS:
				bits |= FI_STORE_OFFSETS_IN_POSTINGS
			case INDEX_OPT_DOCS_AND_FREQS:
				bits |= FI_OMIT_POSITIONS
			}
		}
		if err = output.WriteString(fi.Name); err == nil {
			if err = output.WriteVInt(fi.Number); err == nil {
				err = output.WriteByte(bits)
			}
		}
		if err != nil {
			return
		}

		dv := byte(fi.DocValuesType())
		nrm := byte(fi.NormType())
		assert((dv&(^byte(0xF))) == 0 && (nrm&(^byte(0x0F))) == 0)
		val := (0xff & ((nrm << 4) | dv))
		if err = output.WriteByte(val); err == nil {
			if err = output.WriteLong(fi.DocValuesGen()); err == nil {
				err = output.WriteStringStringMap(fi.Attributes())
			}
		}
		if err != nil {
			return
		}
	}
	if err = codec.WriteFooter(output); err != nil {
		return
	}
	success = true
	return nil
}

Types

type Lucene46FieldInfosFormat

type Lucene46FieldInfosFormat struct {
	// contains filtered or unexported fields
}

func NewLucene46FieldInfosFormat

func NewLucene46FieldInfosFormat() *Lucene46FieldInfosFormat

func (*Lucene46FieldInfosFormat) FieldInfosReader

func (f *Lucene46FieldInfosFormat) FieldInfosReader() FieldInfosReader

func (*Lucene46FieldInfosFormat) FieldInfosWriter

func (f *Lucene46FieldInfosFormat) FieldInfosWriter() FieldInfosWriter

type Lucene46SegmentInfoFormat

type Lucene46SegmentInfoFormat struct {
}

func NewLucene46SegmentInfoFormat

func NewLucene46SegmentInfoFormat() *Lucene46SegmentInfoFormat

func (*Lucene46SegmentInfoFormat) Read

func (f *Lucene46SegmentInfoFormat) Read(dir store.Directory,
	segName string, ctx store.IOContext) (si *SegmentInfo, err error)

func (*Lucene46SegmentInfoFormat) SegmentInfoReader

func (f *Lucene46SegmentInfoFormat) SegmentInfoReader() SegmentInfoReader

func (*Lucene46SegmentInfoFormat) SegmentInfoWriter

func (f *Lucene46SegmentInfoFormat) SegmentInfoWriter() SegmentInfoWriter

func (*Lucene46SegmentInfoFormat) Write

func (f *Lucene46SegmentInfoFormat) Write(dir store.Directory, si *SegmentInfo, fis FieldInfos, ctx store.IOContext) error