logical

type CommonSchema struct {
	Group      *commonv1.Group
	IndexRules []*databasev1.IndexRule
	TagMap     map[string]*TagSpec
	EntityList []string
}

type ComparableExpr interface {
	LiteralExpr
	Compare(LiteralExpr) (int, bool)
	BelongTo(LiteralExpr) bool
	Contains(LiteralExpr) bool
}

type Comparator func(a, b tsdb.Item) bool

type Expr interface {
	fmt.Stringer
	DataType() int32
	Equal(Expr) bool
}

type Field struct {
	Name string
}

type FieldKey struct {
	*database_v1.IndexRule
}

type FieldRef struct {
	// Field defines the name of the Field
	Field *Field
	// spec contains the index of the key in the measureSchema, as well as the underlying FieldSpec
	Spec *FieldSpec
}

type FieldSpec struct {
	FieldIdx int
	Spec     *databasev1.FieldSpec
}

type GlobalIndexError struct {
	IndexRule *database_v1.IndexRule
	Expr      LiteralExpr
}

type ItemIterator interface {
	HasNext() bool
	Next() tsdb.Item
}

type Limit struct {
	*Parent
	LimitNum uint32
}

type LiteralExpr interface {
	Expr
	Bytes() [][]byte
}

type Offset struct {
	*Parent
	// contains filtered or unexported fields
}

type OrderBy struct {
	// orderByIndex describes the indexRule used to sort the elements/
	// It can be null since by default we may sort by created-time.
	Index *databasev1.IndexRule
	// while orderBySort describes the Sort direction
	Sort modelv1.Sort
	// contains filtered or unexported fields
}

type Parent struct {
	UnresolvedInput UnresolvedPlan
	Input           Plan
}

type Plan interface {
	fmt.Stringer
	Children() []Plan
	Schema() Schema
}

type RangeOpts struct {
	Upper         ComparableExpr
	Lower         ComparableExpr
	IncludesUpper bool
	IncludesLower bool
}

type ResolvableExpr interface {
	Expr
	Resolve(Schema) error
}

type Schema interface {
	Scope() tsdb.Entry
	EntityList() []string
	IndexDefined(tagName string) (bool, *databasev1.IndexRule)
	IndexRuleDefined(string) (bool, *databasev1.IndexRule)
	CreateTagRef(tags ...[]*Tag) ([][]*TagRef, error)
	CreateFieldRef(fields ...*Field) ([]*FieldRef, error)
	ProjTags(refs ...[]*TagRef) Schema
	ProjFields(refs ...*FieldRef) Schema
	Equal(Schema) bool
	ShardNumber() uint32
	TraceIDFieldName() string
}

type SeekerBuilder func(builder tsdb.SeekerBuilder)

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

type TagFilter interface {
	fmt.Stringer
	Match(tagFamilies []*model_v1.TagFamily) (bool, error)
}

type TagRef struct {
	// Tag defines the family name and name of the Tag
	Tag *Tag
	// spec contains the index of the key in the streamSchema/measureSchema, as well as the underlying tagSpec
	Spec *TagSpec
}

type TagSpec struct {
	// Idx is defined as
	// 1) the field index based on the (stream/measure) schema for the underlying plans which
	//    directly interact with the database and index modules,
	// 2) the projection index given by the users for those plans which can only access the data from parent plans,
	//    e.g. orderBy plan uses this projection index to access the data entities (normally a projection view)
	//    from the parent plan.
	TagFamilyIdx int
	TagIdx       int
	Spec         *databasev1.TagSpec
}

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

type UnresolvedPlan interface {
	Analyze(Schema) (Plan, error)
}