sparseindex

package

Go to main page

Versions in this module

v1

v1.2.0

Feb 29, 2024

Changes in this version

+ const BloomFilterFilePrefix

+ const BloomFilterFileSuffix

+ const FullTextIdxColumnCnt

+ const FullTextIndex

+ var SKFileReaderOnce sync.Once

+ func GetBloomFilterFilePath(dir, msName, fieldName string) string

+ func GetFullTextAttachFilePath(dir, msName, dataFilePath string) string

+ func GetFullTextDetachFilePath(dir, msName string) string

+ func GetLocalBloomFilterBlockCnts(dir, msName, lockPath string, recSchema record.Schemas, skipIndex *SkipIndex, ...) int64

+ func RegistrySKFileReaderCreator(name string, creator SKFileReaderCreator) bool

+ type BloomFilterFullTextIndexReader struct

+ func NewBloomFilterFullTextIndexReader(rpnExpr *rpn.RPNExpr, schema record.Schemas, option hybridqp.Options, ...) (*BloomFilterFullTextIndexReader, error)

+ func (r *BloomFilterFullTextIndexReader) Close() error

+ func (r *BloomFilterFullTextIndexReader) MayBeInFragment(fragId uint32) (bool, error)

+ func (r *BloomFilterFullTextIndexReader) ReInit(file interface{}) (err error)

+ type BloomFilterFullTextReaderCreator struct

+ func (index *BloomFilterFullTextReaderCreator) CreateSKFileReader(rpnExpr *rpn.RPNExpr, schema record.Schemas, option hybridqp.Options, ...) (SKFileReader, error)

+ type BloomFilterIndexReader struct

+ func NewBloomFilterIndexReader(rpnExpr *rpn.RPNExpr, schema record.Schemas, option hybridqp.Options, ...) (*BloomFilterIndexReader, error)

+ func (r *BloomFilterIndexReader) Close() error

+ func (r *BloomFilterIndexReader) MayBeInFragment(fragId uint32) (bool, error)

+ func (r *BloomFilterIndexReader) ReInit(file interface{}) (err error)

+ type BloomFilterReaderCreator struct

+ func (index *BloomFilterReaderCreator) CreateSKFileReader(rpnExpr *rpn.RPNExpr, schema record.Schemas, option hybridqp.Options, ...) (SKFileReader, error)

+ type BloomFilterWriter struct

+ func NewBloomFilterWriter(dir, msName, dataFilePath, lockPath string) *BloomFilterWriter

+ func (b *BloomFilterWriter) Close() error

+ func (b *BloomFilterWriter) CreateAttachSkipIndex(schemaIdx, rowsPerSegment []int, writeRec *record.Record) error

+ func (b *BloomFilterWriter) CreateDetachSkipIndex(writeRec *record.Record, schemaIdx, rowsPerSegment []int, dataBuf [][]byte) ([][]byte, []string)

+ func (b *BloomFilterWriter) GenBloomFilterData(src *record.ColVal, rowsPerSegment []int, refType int) []byte

+ func (b *BloomFilterWriter) Open() error

+ type FullTextIdxWriter struct

+ func NewFullTextIdxWriter(dir, msName, dataFilePath, lockPath string) *FullTextIdxWriter

+ func (f *FullTextIdxWriter) Close() error

+ func (f *FullTextIdxWriter) CreateAttachSkipIndex(schemaIdx, rowsPerSegment []int, writeRec *record.Record) error

+ func (f *FullTextIdxWriter) CreateDetachSkipIndex(writeRec *record.Record, schemaIdx, rowsPerSegment []int, dataBuf [][]byte) ([][]byte, []string)

+ func (f *FullTextIdxWriter) Open() error

type KeyCondition

+ AlwaysInRange func() (bool, error)

+ CheckInRange func(rgs []*Range, dataTypes []int) (Mark, error)

type KeyConditionImpl

+ func (kc *KeyConditionImpl) AlwaysInRange() (bool, error)

+ type MinMaxIndexReader struct

+ ReadFunc func(file interface{}, rec *record.Record, isCache bool) (*record.Record, error)

+ func NewMinMaxIndexReader(rpnExpr *rpn.RPNExpr, schema record.Schemas, option hybridqp.Options, ...) (*MinMaxIndexReader, error)

+ func (r *MinMaxIndexReader) Close() error

+ func (r *MinMaxIndexReader) MayBeInFragment(fragId uint32) (bool, error)

+ func (r *MinMaxIndexReader) ReInit(file interface{}) (err error)

+ type MinMaxReaderCreator struct

+ func (creator *MinMaxReaderCreator) CreateSKFileReader(rpnExpr *rpn.RPNExpr, schema record.Schemas, option hybridqp.Options, ...) (SKFileReader, error)

+ type MinMaxWriter struct

+ func NewMinMaxWriter(dir, msName, dataFilePath, lockPath string) *MinMaxWriter

+ func (m *MinMaxWriter) Close() error

+ func (m *MinMaxWriter) CreateAttachSkipIndex(schemaIdx, rowsPerSegment []int, writeRec *record.Record) error

+ func (m *MinMaxWriter) CreateDetachSkipIndex(writeRec *record.Record, schemaIdx, rowsPerSegment []int, dataBuf [][]byte) ([][]byte, []string)

+ func (m *MinMaxWriter) Open() error

+ type OBSFilterPath struct

+ func NewOBSFilterPath(localPath, remotePath string, option *obs.ObsOptions) *OBSFilterPath

+ func (o *OBSFilterPath) LocalPath() string

+ func (o *OBSFilterPath) Name() string

+ func (o *OBSFilterPath) Option() *obs.ObsOptions

+ func (o *OBSFilterPath) RemotePath() string

+ type PKIndexReader interface

+ Close func() error

+ Scan func(pkFile string, pkRec *record.Record, pkMark fragment.IndexFragment, ...) (fragment.FragmentRanges, error)

+ type PKIndexReaderImpl struct

+ func NewPKIndexReader(rowsNumPerFragment int, coarseIndexFragment int, minRowsForSeek int) *PKIndexReaderImpl

+ func (r *PKIndexReaderImpl) Close() error

+ func (r *PKIndexReaderImpl) Scan(pkFile string, pkRec *record.Record, pkMark fragment.IndexFragment, ...) (fragment.FragmentRanges, error)

+ type PKIndexWriter interface

+ Build func(srcRec *record.Record, pkSchema record.Schemas, rowsNumPerFragment []int, ...) (*record.Record, fragment.IndexFragment, error)

+ Close func() error

+ type PKIndexWriterImpl struct

+ func NewPKIndexWriter() *PKIndexWriterImpl

+ func (w *PKIndexWriterImpl) Build(srcRec *record.Record, pkSchema record.Schemas, rowsNumPerFragment []int, ...) (*record.Record, fragment.IndexFragment, error)

+ func (w *PKIndexWriterImpl) Close() error

type RPNElement

+ func NewRPNElement(op rpn.Op) *RPNElement

+ type SKCondition interface

+ IsExist func(blockId int64, reader rpn.SKBaseReader) (bool, error)

+ func NewSKCondition(rpnExpr *rpn.RPNExpr, schema record.Schemas) (SKCondition, error)

+ type SKConditionImpl struct

+ func (c *SKConditionImpl) IsExist(blockId int64, reader rpn.SKBaseReader) (bool, error)

+ type SKFileReader interface

+ Close func() error

+ MayBeInFragment func(fragId uint32) (bool, error)

+ ReInit func(file interface{}) error

+ type SKFileReaderCreator interface

+ CreateSKFileReader func(rpnExpr *rpn.RPNExpr, schema record.Schemas, option hybridqp.Options, ...) (SKFileReader, error)

+ type SKFileReaderCreatorFactory struct

+ var SKFileReaderInstance *SKFileReaderCreatorFactory

+ func GetSKFileReaderFactoryInstance() *SKFileReaderCreatorFactory

+ func NewSKFileReaderCreatorFactory() *SKFileReaderCreatorFactory

+ func (s *SKFileReaderCreatorFactory) Add(name string, creator SKFileReaderCreator)

+ func (s *SKFileReaderCreatorFactory) Find(name string) (SKFileReaderCreator, bool)

+ type SKIndexReader interface

+ Close func() error

+ CreateSKFileReaders func(option hybridqp.Options, mstInfo *influxql.Measurement, isCache bool) ([]SKFileReader, error)

+ Scan func(reader SKFileReader, rgs fragment.FragmentRanges) (fragment.FragmentRanges, error)

+ type SKIndexReaderImpl struct

+ func NewSKIndexReader(rowsNumPerFragment int, coarseIndexFragment int, minRowsForSeek int) *SKIndexReaderImpl

+ func (r *SKIndexReaderImpl) Close() error

+ func (r *SKIndexReaderImpl) CreateSKFileReaders(option hybridqp.Options, mstInfo *influxql.Measurement, isCache bool) ([]SKFileReader, error)

+ func (r *SKIndexReaderImpl) Scan(reader SKFileReader, rgs fragment.FragmentRanges) (fragment.FragmentRanges, error)

+ type SetIndexReader struct

+ func NewSetIndexReader(rpnExpr *rpn.RPNExpr, schema record.Schemas, option hybridqp.Options, ...) (*SetIndexReader, error)

+ func (r *SetIndexReader) Close() error

+ func (r *SetIndexReader) MayBeInFragment(fragId uint32) (bool, error)

+ func (r *SetIndexReader) ReInit(file interface{}) (err error)

+ type SetReaderCreator struct

+ func (index *SetReaderCreator) CreateSKFileReader(rpnExpr *rpn.RPNExpr, schema record.Schemas, option hybridqp.Options, ...) (SKFileReader, error)

+ type SetWriter struct

+ func NewSetWriter(dir, msName, dataFilePath, lockPath string) *SetWriter

+ func (s *SetWriter) Close() error

+ func (s *SetWriter) CreateAttachSkipIndex(schemaIdx, rowsPerSegment []int, writeRec *record.Record) error

+ func (s *SetWriter) CreateDetachSkipIndex(writeRec *record.Record, schemaIdx, rowsPerSegment []int, dataBuf [][]byte) ([][]byte, []string)

+ func (s *SetWriter) Open() error

+ type SkInfo struct

+ type SkipIndex struct

+ func NewSkipIndex() *SkipIndex

+ func (s *SkipIndex) GenSchemaIdxes(schema record.Schemas, indexRelation influxql.IndexRelation)

+ func (s *SkipIndex) GetBfIdx() int

+ func (s *SkipIndex) GetFullTextIdx() int

+ func (s *SkipIndex) GetSchemaIdxes() [][]int

+ func (s *SkipIndex) GetSkipIndexWriters() []SkipIndexWriter

+ func (s *SkipIndex) NewSkipIndexWriters(dir, msName, dataFilePath, lockPath string, ...)

+ type SkipIndexWriter interface

+ Close func() error

+ CreateAttachSkipIndex func(schemaIdx, rowsPerSegment []int, writeRec *record.Record) error

+ CreateDetachSkipIndex func(writeRec *record.Record, schemaIdx, rowsPerSegment []int, dataBuf [][]byte) ([][]byte, []string)

+ Open func() error

+ func NewSkipIndexWriter(dir, msName, dataFilePath, lockPath, indexType string) SkipIndexWriter

+ type TsspFile interface

+ Name func() string

+ Path func() string

v1.1.2

Oct 30, 2023

v1.1.1

Nov 7, 2023

v1.1.0

Sep 28, 2023

Changes in this version

+ const Continuous

+ const Empty

+ var ConsiderOnlyBeTrue = NewMark(false, true)

+ var InitIndexFragmentFixedSize = true

+ var NEGATIVE_INFINITY = &FieldRef

+ var POSITIVE_INFINITY = &FieldRef

+ func IsLogicalOperator(op influxql.Token) bool

+ type ColumnRef struct

+ func NewColumnRef(name string, dataType int, column *record.ColVal) *ColumnRef

+ type FieldRef struct

+ func NewFieldRef(cols []*ColumnRef, column int, row int) *FieldRef

+ func (f *FieldRef) Equals(rhs *FieldRef) bool

+ func (f *FieldRef) IsNegativeInfinity() bool

+ func (f *FieldRef) IsNull() bool

+ func (f *FieldRef) IsPositiveInfinity() bool

+ func (f *FieldRef) Less(rhs *FieldRef) bool

+ func (f *FieldRef) Set(cols []*ColumnRef, column, row int)

+ func (f *FieldRef) SetNegativeInfinity()

+ func (f *FieldRef) SetPositiveInfinity()

+ type FunctionBase struct

+ type IndexProperty struct

+ CoarseIndexFragment int

+ MinRowsForSeek int

+ RowsNumPerFragment int

+ func NewIndexProperty(rowsNumPerFragment, coarseIndexFragment, minRowsForSeek int) *IndexProperty

+ type IndexReader interface

+ Close func() error

+ Scan func(pkFile string, pkRec *record.Record, pkMark fragment.IndexFragment, ...) (fragment.FragmentRanges, error)

+ type IndexReaderImpl struct

+ func NewIndexReader(rowsNumPerFragment int, coarseIndexFragment int, minRowsForSeek int) *IndexReaderImpl

+ func (s *IndexReaderImpl) Close() error

+ func (s *IndexReaderImpl) Scan(pkFile string, pkRec *record.Record, pkMark fragment.IndexFragment, ...) (fragment.FragmentRanges, error)

+ type IndexWriter interface

+ Close func() error

+ CreatePrimaryIndex func(srcRec *record.Record, pkSchema record.Schemas, rowsNumPerFragment int) (*record.Record, fragment.IndexFragment, error)

+ type IndexWriterImpl struct

+ func NewIndexWriter() *IndexWriterImpl

+ func (w *IndexWriterImpl) Close() error

+ func (w *IndexWriterImpl) CreatePrimaryIndex(srcRec *record.Record, pkSchema record.Schemas, rowsNumPerFragment int) (*record.Record, fragment.IndexFragment, error)

+ type KeyCondition interface

+ CanDoBinarySearch func() bool

+ GetMaxKeyIndex func() int

+ HavePrimaryKey func() bool

+ IsFirstPrimaryKey func() bool

+ MayBeInRange func(usedKeySize int, indexLeft []*FieldRef, indexRight []*FieldRef, ...) (bool, error)

+ type KeyConditionImpl struct

+ func NewKeyCondition(condition influxql.Expr, pkSchema record.Schemas) *KeyConditionImpl

+ func (kc *KeyConditionImpl) CanDoBinarySearch() bool

+ func (kc *KeyConditionImpl) CheckInRange(rgs []*Range, dataTypes []int) (Mark, error)

+ func (kc *KeyConditionImpl) GetMaxKeyIndex() int

+ func (kc *KeyConditionImpl) GetRPN() []*RPNElement

+ func (kc *KeyConditionImpl) HavePrimaryKey() bool

+ func (kc *KeyConditionImpl) IsFirstPrimaryKey() bool

+ func (kc *KeyConditionImpl) MayBeInRange(usedKeySize int, leftKeys []*FieldRef, rightKeys []*FieldRef, dataTypes []int) (bool, error)

+ func (kc *KeyConditionImpl) SetRPN(rpn []*RPNElement)

+ type Mark struct

+ func NewMark(canBeTrue, canBeFalse bool) Mark

+ func (m Mark) And(mask Mark) Mark

+ func (m Mark) Not() Mark

+ func (m Mark) Or(mask Mark) Mark

+ type Operator uint8

+ const AND

+ const InRange

+ const InSet

+ const NOT

+ const NotInRange

+ const NotInSet

+ const OR

+ const UNKNOWN

+ func InfluxOpToFunction(op influxql.Token) Operator

+ type RPNElement struct

+ type Range struct

+ func NewRange(left, right *FieldRef, li, ri bool) *Range

+ type SetIndex struct

+ func (si *SetIndex) Not() bool

v1.1.0-rc1

Aug 31, 2023

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL