squery

type Builder interface {
	Build(sb StringBuilder, ph Placeholder) ([]interface{}, error)
}

type DataList struct {
	Success    bool        `json:"success"`
	Total      int64       `json:"total"`
	DataCount  int         `json:"dataCount"`
	Pagination *Pagination `json:"pagination,omitempty"`
	Data       interface{} `json:"data"`
}

type DbColumn struct {
	ColumnExpr string  `json:"columnExpr"`
	Label      string  `json:"label"`
	DataType   *string `json:"dataType"`
}

type EqFilter struct {
	Field string      `json:"field"`
	Value interface{} `json:"value"`
}

type Error interface {
	Err() error
}

type Expression interface {
	Builder
	IsEmpty() bool
}

type ExpressionBuilder interface {
	Or(expr1, expr2 Expression, exprs ...Expression) Expression
	And(expr1, expr2 Expression, exprs ...Expression) Expression
	Null(term Term) Expression
	NotNull(term Term) Expression
	Not(expr Expression) Expression
	Eq(term Term, arg interface{}) Expression
	Neq(term Term, arg interface{}) Expression
	Gt(term Term, arg interface{}) Expression
	Gte(term Term, arg interface{}) Expression
	Lt(term Term, arg interface{}) Expression
	Lte(term Term, arg interface{}) Expression
	Like(term Term, arg interface{}) Expression
	ILike(term Term, arg interface{}) Expression
	SimilarTo(term Term, arg interface{}) Expression
	NotLike(term Term, arg interface{}) Expression
	NotILike(term Term, arg interface{}) Expression
	NotSimilarTo(term Term, arg interface{}) Expression
	Between(term Term, arg1, arg2 interface{}) Expression
	In(term Term, args ...interface{}) Expression
	NotIn(term Term, args ...interface{}) Expression
	Raw(query string, args ...interface{}) Expression
}

type Expressions interface {
	Builder
	Expression() Expression
	Set(expr Expression) Expressions
	Or(expr Expression, exprs ...Expression) Expressions
	And(expr Expression, exprs ...Expression) Expressions
}

type F string

type FieldMapSelector func(field string, val interface{}) (string, interface{}, bool)

type FieldValues map[string]interface{}

type FnMapField func(string) (string, error)

type Functor interface {
	Builder
	Func(name string, args ...interface{}) Functor
	Name() string
	Fields() []F
}

type ListSearchArg struct {
	Sorts      SortConditions  `json:"sorts,omitempty"`
	Pagination *Pagination     `json:"pagination,omitempty"`
	Filter     json.RawMessage `json:"filter"`
	Query      *QueryTerm      `json:"query,omitempty"`
	Fields     []string        `json:"fields,omitempty"`
}

type M string

type MapSlice []map[string]interface{}

type Pagination struct {
	Page        int64   `json:"page"`    // starts from 0
	PerPage     int64   `json:"perPage"` // number of record in one page
	NextPageKey *string `json:"nextPageKey"`
	// contains filtered or unexported fields
}

type Placeholder interface {
	Next() string
	Position() int
}

type Property struct {
	DefaultLabel    string            `json:"defaultLabel"`
	TranslatedLabel map[string]string `json:"translatedLabel"`
	Value           interface{}       `json:"value"`
	DataType        *string           `json:"dataType"`
}

type Querier interface {
	Error
	One(ctx context.Context, dest interface{}) error
	OneMap(ctx context.Context, fm FieldMapSelector) (map[string]interface{}, error)
	Many(ctx context.Context, dest interface{}) error
	ManyMap(ctx context.Context, fm FieldMapSelector) (MapSlice, error)
	Count(ctx context.Context) (int64, error)
}

type QuerierConstructor interface {
	NamedQuery(query string, arg interface{}, hasIn bool, logFields ...interface{}) Querier
	Query(query string, args []interface{}, logFields ...interface{}) Querier
	InQuery(query string, args []interface{}, logFields ...interface{}) Querier
	RebindQuery(query string, args []interface{}, logFields ...interface{}) Querier
	WithSelector(s Selector, logFields ...interface{}) Querier
}

type Query interface {
	Selector
	From(name Stringer) Query
	Where(expr Expression) Query
	Having(expr Expression) Query
	Columns(cols ...Stringer) Query
	RawColumns(cols ...string) Query
	Limit(n int64) Query
	Offset(n int64) Query
	One() Query
	OrderBy(clause Stringer) Query
	GroupBy(clause Stringer) Query
}

type QueryTerm struct {
	Fields  []string `json:"fields,omitempty"`
	Matcher string   `json:"matcher"`
	Term    string   `json:"term"`
}

type R string

type Raw interface {
	Builder
}

type RefSearchArg struct {
	Target     EqFilter       `json:"target"`
	Sorts      SortConditions `json:"sorts,omitempty"`
	Pagination *Pagination    `json:"pagination,omitempty"`
}

type S string

type SelectColumn struct {
	JsonField   string
	SelectField string
	ResultField string
}

type Selector interface {
	Builder
	Select(cols ...Stringer) (string, []interface{}, error)
	RawSelect(cols ...string) (string, []interface{}, error)
	Count() (string, []interface{}, error)
}

type Sort struct {
	Fields []string `json:"fields"`
	Order  string   `json:"order"`
}

type SortConditions []*Sort

type SqlExpression struct {
	Clause    string        `json:"clause"`
	Args      []interface{} `json:"args"`
	Fields    []string      `json:"fields"`
	SqlFields []string      `json:"sqlFields"`
	// contains filtered or unexported fields
}

type StringBuilder interface {
	Stringer
	io.Writer
	Len() int
	WriteByte(c byte) error
	WriteRune(r rune) (int, error)
	WriteString(s string) (int, error)
}

type Stringer interface {
	String() string
}

type TemplateListSearchArg struct {
	ListSearchArg
	FieldValues    FieldValues          `json:"fieldValues"`
	SelectTemplate string               `json:"-"`
	CountTemplate  string               `json:"-"`
	FieldsMap      map[string]string    `json:"-"`
	SelectColsMap  map[string]*DbColumn `json:"-"`
}

type Term interface {
	Stringer
}

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