index

type Batch struct {
	Documents Documents
}

type Document struct {
	Fields       []Field
	EntityValues []byte
	Timestamp    int64
	DocID        uint64
}

type DocumentResult struct {
	EntityValues []byte
	Values       map[string][]byte
	SortedValue  []byte
	SeriesID     common.SeriesID
	DocID        uint64
	Timestamp    int64
}

type Documents []Document

type Field struct {
	Term   []byte
	Key    FieldKey
	NoSort bool
	Store  bool
}

type FieldIterable interface {
	BuildQuery(seriesMatchers []SeriesMatcher, secondaryQuery Query) (Query, error)
	Iterator(ctx context.Context, fieldKey FieldKey, termRange RangeOpts, order modelv1.Sort,
		preLoadSize int, query Query, fieldKeys []FieldKey) (iter FieldIterator[*DocumentResult], err error)
	Sort(ctx context.Context, sids []common.SeriesID, fieldKey FieldKey,
		order modelv1.Sort, timeRange *timestamp.TimeRange, preLoadSize int) (FieldIterator[*DocumentResult], error)
}

type FieldIterator[T sort.Comparable] interface {
	Next() bool
	Val() T
	Close() error
	Query() Query
}

type FieldKey struct {
	Analyzer    string
	SeriesID    common.SeriesID
	IndexRuleID uint32
}

type Filter interface {
	fmt.Stringer
	Execute(getSearcher GetSearcher, seriesID common.SeriesID) (posting.List, error)
}

type GetSearcher func(location databasev1.IndexRule_Type) (Searcher, error)

type Query interface {
	fmt.Stringer
}

type RangeOpts struct {
	Upper         []byte
	Lower         []byte
	IncludesUpper bool
	IncludesLower bool
}

type Searcher interface {
	FieldIterable
	Match(fieldKey FieldKey, match []string, opts *modelv1.Condition_MatchOption) (list posting.List, err error)
	MatchField(fieldKey FieldKey) (list posting.List, err error)
	MatchTerms(field Field) (list posting.List, err error)
	Range(fieldKey FieldKey, opts RangeOpts) (list posting.List, err error)
}

type Series struct {
	EntityValues []byte
	ID           common.SeriesID
}

type SeriesDocument struct {
	Fields map[string][]byte
	Key    Series
}

type SeriesMatcher struct {
	Match []byte
	Type  SeriesMatcherType
}

type SeriesMatcherType int

type SeriesStore interface {
	Store
	// Search returns a list of series that match the given matchers.
	Search(context.Context, []FieldKey, Query) ([]SeriesDocument, error)
}

type Store interface {
	io.Closer
	Writer
	Searcher
	CollectMetrics(...string)
}

type Writer interface {
	Batch(batch Batch) error
}