tsdb

type BlockID struct {
	SegID   SectionID
	BlockID SectionID
}

type BlockState struct {
	TimeRange timestamp.TimeRange
	ID        BlockID
	Closed    bool
}

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

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

type CompressionMethod struct {
	Type             CompressionType
	ChunkSizeInBytes int
}

type CompressionType int

type Database interface {
	io.Closer
	CreateShardsAndGetByID(id common.ShardID) (Shard, error)
	Shards() []Shard
	Shard(id common.ShardID) (Shard, error)
}

type DatabaseOpts struct {
	TSTableFactory     TSTableFactory
	Location           string
	SegmentInterval    IntervalRule
	BlockInterval      IntervalRule
	TTL                IntervalRule
	BlockInvertedIndex InvertedIndexOpts
	SeriesMemSize      run.Bytes
	GlobalIndexMemSize run.Bytes
	IndexGranularity   IndexGranularity
	ShardNum           uint32
	EnableGlobalIndex  bool
	EnableWAL          bool
}

type EncodingMethod struct {
	EncoderPool      encoding.SeriesEncoderPool
	DecoderPool      encoding.SeriesDecoderPool
	ChunkSizeInBytes int
}

type Entity []Entry

type EntityValue = *modelv1.TagValue

type EntityValues []EntityValue

type Entry []byte

type GlobalItemID struct {
	ShardID common.ShardID

	SeriesID common.SeriesID
	ID       common.ItemID
	// contains filtered or unexported fields
}

type IndexDatabase interface {
	WriterBuilder() IndexWriterBuilder
	Seek(field index.Field) ([]GlobalItemID, error)
}

type IndexGranularity int

type IndexWriter interface {
	WriteLSMIndex(field []index.Field) error
	WriteInvertedIndex(field []index.Field) error
}

type IndexWriterBuilder interface {
	Scope(scope Entry) IndexWriterBuilder
	Time(ts time.Time) IndexWriterBuilder
	GlobalItemID(itemID GlobalItemID) IndexWriterBuilder
	Build() (IndexWriter, error)
}

type IntervalRule struct {
	Unit IntervalUnit
	Num  int
}

type IntervalUnit int

type InvertedIndexOpts struct {
	BatchWaitSec int64
}

type Item interface {
	Family(family []byte) ([]byte, error)
	Val() ([]byte, error)
	ID() common.ItemID
	SortedField() []byte
	Time() uint64
}

type Iterator interface {
	Next() bool
	Val() Item
	Close() error
}

type OrderBy struct {
	Index *databasev1.IndexRule
	Sort  modelv1.Sort
}

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

type SectionID uint32

type Seeker interface {
	Seek() ([]Iterator, error)
}

type SeekerBuilder interface {
	Filter(predicator index.Filter) SeekerBuilder
	OrderByIndex(indexRule *databasev1.IndexRule, order modelv1.Sort) SeekerBuilder
	OrderByTime(order modelv1.Sort) SeekerBuilder
	Build() (Seeker, error)
}

type Series interface {
	ID() common.SeriesID
	Span(ctx context.Context, timeRange timestamp.TimeRange) (SeriesSpan, error)
	Create(ctx context.Context, t time.Time) (SeriesSpan, error)
	Get(ctx context.Context, id GlobalItemID) (Item, io.Closer, error)
	String() string
}

type SeriesDatabase interface {
	io.Closer
	GetByID(id common.SeriesID) (Series, error)
	Get(key []byte, entityValues EntityValues) (Series, error)
	List(ctx context.Context, path Path) (SeriesList, error)
	Search(ctx context.Context, path Path, filter index.Filter, order *OrderBy) (SeriesList, error)
	SizeOnDisk() int64
	// contains filtered or unexported methods
}

type SeriesList []Series

type SeriesSpan interface {
	io.Closer
	WriterBuilder() WriterBuilder
	SeekerBuilder() SeekerBuilder
}

type Shard interface {
	io.Closer
	ID() common.ShardID
	Series() SeriesDatabase
	Index() IndexDatabase
	State() ShardState
	// Only works with MockClock
	TriggerSchedule(task string) bool
}

type ShardState struct {
	Blocks           []BlockState
	OpenBlocks       []BlockID
	StrategyManagers []string
}

type Supplier interface {
	SupplyTSDB() Database
}

type TSTable interface {
	// Put a value with a timestamp/version
	Put(key, val []byte, ts time.Time) error
	// Get a value by its key and timestamp/version
	Get(key []byte, ts time.Time) ([]byte, error)
	// CollectStats collects statistics of the underlying storage.
	CollectStats() *badger.Statistics
	// SizeOnDisk returns the size of the underlying storage.
	SizeOnDisk() int64
	io.Closer
}

type TSTableFactory interface {
	// NewTSTable creates a new TSTable.
	NewTSTable(bufferSupplier *BufferSupplier, root string, position common.Position,
		l *logger.Logger, timeRange timestamp.TimeRange) (TSTable, error)
}

type Writer interface {
	IndexWriter
	Write() (GlobalItemID, error)
	ItemID() GlobalItemID
	String() string
}

type WriterBuilder interface {
	Family(name []byte, val []byte) WriterBuilder
	Time(ts time.Time) WriterBuilder
	Val(val []byte) WriterBuilder
	Build() (Writer, error)
}