logical

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

type CommonSchema struct {
	TagSpecMap
	IndexRules []*databasev1.IndexRule
	EntityList []string
}

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

type Expr interface {
	fmt.Stringer
	Elements() []string
	DataType() int32
	Equal(Expr) bool
}

type Field struct {
	Name string
}

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 {
	Spec     *databasev1.FieldSpec
	FieldIdx int
}

type IndexChecker interface {
	IndexDefined(tagName string) (bool, *databasev1.IndexRule)
	IndexRuleDefined(ruleName string) (bool, *databasev1.IndexRule)
}

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

type OptimizeRule interface {
	Optimize(Plan) (Plan, error)
}

type OrderBy struct {
	Index *databasev1.IndexRule

	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 PushDownMaxSize struct {
	// contains filtered or unexported fields
}

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

type Schema interface {
	TagSpecRegistry
	IndexChecker
	EntityList() []string
	CreateTagRef(tags ...[]*Tag) ([][]*TagRef, error)
	CreateFieldRef(fields ...*Field) ([]*FieldRef, error)
	ProjTags(refs ...[]*TagRef) Schema
	ProjFields(refs ...*FieldRef) Schema
	Equal(Schema) bool
}

type Sorter interface {
	Plan
	Sort(order *OrderBy)
}

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

type TagFamilies []*modelv1.TagFamily

type TagFamiliesForWrite []*modelv1.TagFamilyForWrite

type TagFilter interface {
	fmt.Stringer
	Match(accessor TagValueIndexAccessor, registry TagSpecRegistry) (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 {
	Spec         *databasev1.TagSpec
	TagFamilyIdx int
	TagIdx       int
}

type TagSpecMap map[string]*TagSpec

type TagSpecRegistry interface {
	FindTagSpecByName(string) *TagSpec
}

type TagValueIndexAccessor interface {
	GetTagValue(tagFamilyIdx, tagIdx int) *modelv1.TagValue
}

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

type VolumeLimiter interface {
	Plan
	Limit(max int)
}