grammer

type AllExpression struct {
	ExpressionBase
}

type BtwComparableExpression struct {
	ComparableExpression
	A   interface{}
	B   interface{}
	Gte bool // 是否左包含
	Lte bool // 是否右包含
}

type CollapseAdapter struct {
}

type ComparableExpression struct {
	ExpressionBase
	Field string
	Paths []string // nested field's path, e.g. 字段a.b.c.d的paths是 [a, a.b, a.b.c]
	Not   bool     // 是否是not语义, 按boolean异或生成, not not = false, not != 为 false , not = 为 true

}

type ExportClause struct {
	Fields     []string
	FileName   string
	FileType   string
	Sep        string
	SaveHeader bool
	Headers    []string
	FetchCode  int
}

type Expression interface {
	// EnrichQueryBuilder use for single condition or '!=' or 'not' logic
	//	将自身放到boolQuery中
	EnrichBoolQueryBuilder(boolQuery *elastic.BoolQuery)
	ToQueryBuilder() elastic.Query
	GetNeedScore() bool
	//AdaptToQueryBuilder(ctx *basic.ExeElasticSQLCtx) elastic.Query
	SetNeedScore(score bool)
	IsComparableExpression() bool
	IsLogicExpression() bool
}

type ExpressionBase struct {
	NeedScore bool    // 是否算分
	Boost     float64 // for boost
}

type FullLevelFunctionalComparableExpression struct {
	ComparableExpression
	Func  string
	Props map[string]interface{}
}

type FunctionalComparableExpression struct {
	ComparableExpression
	Func   string
	Params []interface{}
	// contains filtered or unexported fields
}

type HighlightAdapter struct {
	FieldAndSchema    map[string]string
	FieldSchema       []string // as
	Tag               string   // 与filed对应
	FragmentSize      int
	NumberOfFragments int
	NoMatchSize       int
}

type IComparableExpression interface {
	Expression
	GetField() string
	SetField(field string)
	GetPaths() []string
	SetPaths(paths []string)
	SetNot(not bool)
	GetNot() bool
	NestedSingleCondition(query elastic.Query) elastic.Query
}

type LogicExpression struct {
	ExpressionBase

	SubExpr []Expression // 所有的子表达式

	PathExpr *PathTree // 用PathTree存储该logic-expr中的nested条件

	FB bool // 是否有括号强制(Force Bracket) 单独Logic 而不是和相同的path合并

	Nested        bool   // 是否有nested类型字段条件
	UniParentPath string // 子表达式的统一parentPath
	Not           bool   // 是否有 not(xxx)  专门用于 nested not
	Logic         string // 默认无LOGIC

	HasSub bool // 是否是含有子表达式 初始化后是空的为false AddSubExpr 之后就不为空 为true
}

type MultiTreeNode struct {
	Path          string
	Layer         int
	Datas         []*TreeNode
	NonRangeExprs []IComparableExpression
	RangeExprs    map[string][]*TermComparableExpression
	// contains filtered or unexported fields
}

type PathTree struct {
	Root        *MultiTreeNode
	NestedPaths map[string]basic.Void // 存放所有的nested path 也就是parentPath
}

type RescoreAdapter struct {
}

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

type SortAdapter struct {
	Field          string
	Ascending      bool
	OrderLogic     int // asc 1 , desc -1, used for mem-sort
	Mode           string
	NestedFilter   Expression
	Script         *ScriptAdapter
	ScriptSortType string
}

type TermComparableExpression struct {
	ComparableExpression
	Operator string
	Value    interface{}
}

type TermGroup []*TermComparableExpression

type TreeNode struct {
	Expr        IComparableExpression // 节点表达式
	ParentPath  string                // paths的最后一个. 如 a.b.c.d = 1 的 parentPath 是 a.b.c
	PathsOnTree []string              // paths, 如 a.b.c.d = 1 的paths is ['a','a.b','a.b.c']
	Layer       int                   // 加在第几层 len(paths)
}