expr

May 6, 2024

Changes in this version

+ var All = &RawExpr

+ var C = Const

+ var Count = &FuncExpr

+ var CountAll = &FuncExpr

+ var F = Fn

+ var LeftBracket = &RawExpr

+ var N = Name

+ var NULL = &ConstantExpr

+ var R = Raw

+ var RightBracket = &RawExpr

+ var V = Var

+ func AllToAnd(exp Expr)

+ func AllToOr(exp Expr)

+ func AutoFuzzy(exp Expr)

+ func WithCount(exp Expr)

+ type AliasExpr struct

+ Alias string

+ Expr Expr

+ func Alias(expr Expr, alias string) *AliasExpr

+ func (a *AliasExpr) Format(buffer *TracedBuffer)

+ type AroundExpr struct

+ Expr Expr

+ Prefix Expr

+ Suffix Expr

+ func Paren(expr Expr) *AroundExpr

+ func (s *AroundExpr) Format(buffer *TracedBuffer)

+ type BetweenExpr struct

+ End Expr

+ Left Expr

+ Start Expr

+ func Between(left Expr, start Expr, end Expr) *BetweenExpr

+ func (b *BetweenExpr) Format(buffer *TracedBuffer)

+ type BinaryExpr struct

+ Left Expr

+ Operator string

+ Right Expr

+ Space string

+ func Binary(left Expr, op string, right any) *BinaryExpr

+ func Eq(left Expr, right any) *BinaryExpr

+ func Ge(left Expr, right any) *BinaryExpr

+ func Gt(left Expr, right any) *BinaryExpr

+ func In(left Expr, name string, values ...any) *BinaryExpr

+ func InValues(left Expr, values ...Expr) *BinaryExpr

+ func Le(left Expr, right any) *BinaryExpr

+ func Like(left Expr, right any) *BinaryExpr

+ func Lt(left Expr, right any) *BinaryExpr

+ func Ne(left Expr, right any) *BinaryExpr

+ func NotIn(left Expr, name string, values ...any) *BinaryExpr

+ func NotInValues(left Expr, values ...Expr) *BinaryExpr

+ func (b *BinaryExpr) Format(buffer *TracedBuffer)

+ func (b *BinaryExpr) UseSpace() *BinaryExpr

+ type ConstantExpr struct

+ Value any

+ func Const(value any) *ConstantExpr

+ func (c *ConstantExpr) Format(buffer *TracedBuffer)

+ type DeleteExpr struct

+ Table Expr

+ WhereExpr Expr

+ func Delete(table Expr) *DeleteExpr

+ func (d *DeleteExpr) Delete(table Expr) *DeleteExpr

+ func (d *DeleteExpr) Format(buf *TracedBuffer)

+ func (d *DeleteExpr) Where(exp Expr) *DeleteExpr

+ type DeleteExprFn func(*DeleteExpr)

+ func UseDeleteCondition(exp Expr) DeleteExprFn

+ type DeleteFilterFn func(s *DeleteExpr)

+ type Expr interface

+ Format func(buffer *TracedBuffer)

+ func Asc(exp Expr) Expr

+ func AutoNamedValues(name string, values ...any) []Expr

+ func Desc(exp Expr) Expr

+ func Sort(exp Expr, direction string) Expr

+ func Sorts(direction string, exps ...Expr) Expr

+ type FilterFn func(Expr)

+ func DeleteFilter(fn DeleteFilterFn) FilterFn

+ func InsertFilter(fn InsertFilterFn) FilterFn

+ func SelectFilter(fn SelectFilterFn) FilterFn

+ func Set(exps ...Expr) FilterFn

+ func UpdateFilter(fn UpdateFilterFn) FilterFn

+ func UseCondition(exp Expr) FilterFn

+ func UseLimit(limit int) FilterFn

+ func UseLimits(limit int, offset int) FilterFn

+ func UseOffset(offset int) FilterFn

+ func UseOrderBy(exp Expr) FilterFn

+ func UseSort(direct string, exprs ...Expr) FilterFn

+ type Filters []FilterFn

+ func (f *Filters) Append(filters ...FilterFn) *Filters

+ func (f *Filters) Apply(exp Expr)

+ func (f *Filters) ApplyAll(exps []Expr)

+ func (f *Filters) Delete(filters ...FilterFn) *Filters

+ func (f *Filters) Select(filters ...FilterFn) *Filters

+ func (f *Filters) Update(filters ...FilterFn)

+ type FuncExpr struct

+ Args []Expr

+ Name string

+ func Fn(name string, args ...Expr) *FuncExpr

+ func (f *FuncExpr) Format(buffer *TracedBuffer)

+ type InsertExpr struct

+ Table Expr

+ ValueExprs []*BinaryExpr

+ func InsertInto(table Expr, values ...*BinaryExpr) *InsertExpr

+ func (i *InsertExpr) Format(buf *TracedBuffer)

+ func (i *InsertExpr) Into(table Expr) *InsertExpr

+ func (i *InsertExpr) Set(colName string, value any) *InsertExpr

+ func (i *InsertExpr) SetExpr(name Expr, value Expr) *InsertExpr

+ func (i *InsertExpr) SetMap(data map[string]any) *InsertExpr

+ func (i *InsertExpr) Values(values ...*BinaryExpr) *InsertExpr

+ type InsertFilterFn func(s *InsertExpr)

+ type ListExpr struct

+ ExprList []Expr

+ Placeholder string

+ Prefix Expr

+ Separator string

+ Suffix Expr

+ func And(exprList ...Expr) *ListExpr

+ func List(operator string, exprList ...Expr) *ListExpr

+ func Or(exprList ...Expr) *ListExpr

+ func (l *ListExpr) Format(buffer *TracedBuffer)

+ type NameExpr struct

+ Name string

+ Qualifier []string

+ func Name(name string, qualifiers ...string) *NameExpr

+ func (n *NameExpr) Between(min, max any) *BetweenExpr

+ func (n *NameExpr) Eq(value any) *BinaryExpr

+ func (n *NameExpr) Format(buffer *TracedBuffer)

+ func (n *NameExpr) Ge(value any) *BinaryExpr

+ func (n *NameExpr) Gt(value any) *BinaryExpr

+ func (n *NameExpr) In(values ...any) *BinaryExpr

+ func (n *NameExpr) Le(value any) *BinaryExpr

+ func (n *NameExpr) Like(value any) *BinaryExpr

+ func (n *NameExpr) Lt(value any) *BinaryExpr

+ func (n *NameExpr) Ne(value any) *BinaryExpr

+ func (n *NameExpr) NotIn(values ...any) *BinaryExpr

+ type RawExpr struct

+ Value any

+ func Raw(value any) *RawExpr

+ func (r *RawExpr) Format(buffer *TracedBuffer)

+ type SelectExpr struct

+ Columns Expr

+ FromExpr Expr

+ GroupByExpr Expr

+ HavingExpr Expr

+ OrderByExpr Expr

+ WhereExpr Expr

+ func Select(columns ...Expr) *SelectExpr

+ func (s *SelectExpr) BuildCountExpr() *SelectExpr

+ func (s *SelectExpr) Format(buffer *TracedBuffer)

+ func (s *SelectExpr) From(from Expr) *SelectExpr

+ func (s *SelectExpr) GroupBy(exp Expr) *SelectExpr

+ func (s *SelectExpr) Having(exp Expr) *SelectExpr

+ func (s *SelectExpr) Limit(limit int) *SelectExpr

+ func (s *SelectExpr) Offset(offset int) *SelectExpr

+ func (s *SelectExpr) OrderBy(exps ...Expr) *SelectExpr

+ func (s *SelectExpr) Select(columns ...Expr) *SelectExpr

+ func (s *SelectExpr) UseCount() bool

+ func (s *SelectExpr) Where(exp Expr) *SelectExpr

+ func (s *SelectExpr) WithCount() *SelectExpr

+ func (s *SelectExpr) WithoutCount() *SelectExpr

+ type SelectFilterFn func(s *SelectExpr)

+ type TracedBuffer struct

+ NamedVar bool

+ func NewTracedBuffer(driver *dialect.Driver) *TracedBuffer

+ func (t *TracedBuffer) Append(buf []byte) *TracedBuffer

+ func (t *TracedBuffer) AppendArg(value any) *TracedBuffer

+ func (t *TracedBuffer) AppendExprs(exprs ...Expr) *TracedBuffer

+ func (t *TracedBuffer) AppendKeyword(keyword string) *TracedBuffer

+ func (t *TracedBuffer) AppendKeywordWithSpace(keyword string) *TracedBuffer

+ func (t *TracedBuffer) AppendNamedArg(name string, value any) *TracedBuffer

+ func (t *TracedBuffer) AppendString(s string) *TracedBuffer

+ func (t *TracedBuffer) Build(exp Expr) (string, []any, error)

+ func (t *TracedBuffer) BuildNamed(exp Expr) (string, map[string]any, error)

+ func (t *TracedBuffer) NewLine() *TracedBuffer

+ type Tuple struct

+ Name Expr

+ Value Expr

+ type UnaryExpr struct

+ Expr Expr

+ Operator string

+ func Not(expr Expr) *UnaryExpr

+ func Unary(operator string, expr Expr) *UnaryExpr

+ func (u *UnaryExpr) Format(buffer *TracedBuffer)

+ type UpdateExpr struct

+ Table Expr

+ Values []Expr

+ WhereExpr Expr

+ func Update(table Expr) *UpdateExpr

+ func (u *UpdateExpr) Format(buf *TracedBuffer)

+ func (u *UpdateExpr) Set(values ...Expr) *UpdateExpr

+ func (u *UpdateExpr) Update(table Expr) *UpdateExpr

+ func (u *UpdateExpr) Where(exp Expr) *UpdateExpr

+ type UpdateFilterFn func(s *UpdateExpr)

+ type ValueExpr struct

+ Name string

+ Value any

+ func Var(name string, value any) *ValueExpr

+ func (n *ValueExpr) Format(buffer *TracedBuffer)