expression

package

Go to main page

Versions in this module

v0

v0.18.1

Apr 9, 2024

Changes in this version

+ const ConvertToYear

+ type AutoUuid struct

+ func NewAutoUuid(_ *sql.Context, col *sql.Column, child sql.Expression) *AutoUuid

+ func (au *AutoUuid) Children() []sql.Expression

+ func (au *AutoUuid) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

+ func (au *AutoUuid) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (au *AutoUuid) IsNullable() bool

+ func (au *AutoUuid) String() string

+ func (au *AutoUuid) Type() sql.Type

+ func (au *AutoUuid) WithChildren(children ...sql.Expression) (sql.Expression, error)

v0.18.0

Feb 28, 2024

Changes in this version

+ var FetchEOF = errors.New("exhausted fetch iterator")

+ func GetConvertToType(l, r sql.Type) string

+ func PreciseComparison(e sql.Expression) bool

+ func SplitDisjunction(expr sql.Expression) []sql.Expression

+ type BinaryExpressionStub struct

+ LeftChild sql.Expression

+ RightChild sql.Expression

+ func (p *BinaryExpressionStub) Children() []sql.Expression

+ func (p *BinaryExpressionStub) IsNullable() bool

+ func (p *BinaryExpressionStub) Left() sql.Expression

+ func (p *BinaryExpressionStub) Resolved() bool

+ func (p *BinaryExpressionStub) Right() sql.Expression

+ type ConvertUsing struct

+ TargetCharSet sql.CharacterSetID

+ func NewConvertUsing(expr sql.Expression, targetCharSet sql.CharacterSetID) *ConvertUsing

+ func (c *ConvertUsing) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

+ func (c *ConvertUsing) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (c *ConvertUsing) String() string

+ func (c *ConvertUsing) Type() sql.Type

+ func (c *ConvertUsing) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type DeclareHandlerAction byte

+ const DeclareHandlerAction_Continue

+ const DeclareHandlerAction_Exit

+ const DeclareHandlerAction_Undo

type GetField

+ func (p *GetField) Database() string

+ func (p *GetField) Id() sql.ColumnId

+ func (p *GetField) IsBackTickNames() bool

+ func (p *GetField) TableID() sql.TableId

+ func (p *GetField) TableId() sql.TableId

+ func (p *GetField) WithBackTickNames(backtick bool) *GetField

+ func (p *GetField) WithId(id sql.ColumnId) sql.IdExpression

+ type HandlerCondition struct

+ SqlStatePrefix string

+ Type HandlerConditionType

+ func (c *HandlerCondition) Matches(err error) bool

+ type HandlerConditionType uint8

+ const HandlerConditionNotFound

+ const HandlerConditionSqlException

+ const HandlerConditionUnknown

type HashInTuple

+ func (hit *HashInTuple) Children() []sql.Expression

+ func (hit *HashInTuple) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

+ func (hit *HashInTuple) Compare(ctx *sql.Context, row sql.Row) (int, error)

+ func (hit *HashInTuple) IsNullable() bool

+ func (hit *HashInTuple) Left() sql.Expression

+ func (hit *HashInTuple) Resolved() bool

+ func (hit *HashInTuple) Right() sql.Expression

+ func (hit *HashInTuple) Type() sql.Type

+ func (hit *HashInTuple) WithChildren(children ...sql.Expression) (sql.Expression, error)

type Mod

+ func (m *Mod) Description() string

+ func (m *Mod) FunctionName() string

type SystemVar

+ SpecifiedScope string

type UnresolvedTableFunction

+ func (utf *UnresolvedTableFunction) IsReadOnly() bool

type Wrapper

+ func (w *Wrapper) DebugString() string

v0.17.0

Aug 23, 2023

Changes in this version

type Alias

+ func (e *Alias) Id() sql.ColumnId

+ func (e *Alias) WithId(id sql.ColumnId) *Alias

+ type MatchAgainst struct

+ Columns []sql.Expression

+ ConfigTable sql.IndexAddressableTable

+ DocCountTable sql.IndexAddressableTable

+ Expr sql.Expression

+ GlobalCountTable sql.IndexAddressableTable

+ KeyCols fulltext.KeyColumns

+ ParentTable sql.IndexAddressableTable

+ PositionTable sql.IndexAddressableTable

+ RowCountTable sql.IndexAddressableTable

+ SearchModifier fulltext.SearchModifier

+ func NewMatchAgainst(columns []sql.Expression, expr sql.Expression, ...) *MatchAgainst

+ func (expr *MatchAgainst) Children() []sql.Expression

+ func (expr *MatchAgainst) ColumnsAsGetFields() []*GetField

+ func (expr *MatchAgainst) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (expr *MatchAgainst) GetIndex() fulltext.Index

+ func (expr *MatchAgainst) IsNullable() bool

+ func (expr *MatchAgainst) Resolved() bool

+ func (expr *MatchAgainst) SetIndex(fulltextIndex fulltext.Index)

+ func (expr *MatchAgainst) String() string

+ func (expr *MatchAgainst) Type() sql.Type

+ func (expr *MatchAgainst) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ func (expr *MatchAgainst) WithInfo(...) *MatchAgainst

type SystemVar

+ Collation sql.CollationID

v0.16.0

Jun 29, 2023

Changes in this version

+ const ConvertToFloat

+ func JoinOr(exprs ...sql.Expression) sql.Expression

+ func NewRangeFilterExpr(exprs []sql.Expression, ranges []sql.Range) (sql.Expression, error)

type Alias

+ func (e *Alias) AsUnreferencable() *Alias

+ func (e *Alias) Unreferencable() bool

type Convert

+ func NewConvertWithLengthAndScale(expr sql.Expression, castToType string, typeLength, typeScale int) *Convert

type UnresolvedTableFunction

+ Alias string

v0.15.0

Apr 18, 2023

Changes in this version

+ const ERDivisionByZero

+ var ErrIntDivDataOutOfRange = errors.NewKind("BIGINT value is out of range (%s DIV %s)")

+ func GetPrecisionAndScale(val interface{}) (uint8, uint8)

+ func SplitConjunction(expr sql.Expression) []sql.Expression

type Alias

+ func (e *Alias) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type AliasReference

+ func (AliasReference) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type And

+ func (*And) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type Arithmetic

+ func (*Arithmetic) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

+ func (a *Arithmetic) LeftChild() sql.Expression

+ func (a *Arithmetic) Operator() string

+ func (a *Arithmetic) RightChild() sql.Expression

+ func (a *Arithmetic) SetOpCount(i int32)

+ type ArithmeticOp interface

+ LeftChild func() sql.Expression

+ Operator func() string

+ RightChild func() sql.Expression

+ SetOpCount func(int32)

type AutoIncrement

+ func (i *AutoIncrement) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type Between

+ func (b *Between) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type Binary

+ func (*Binary) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type BindVar

+ func (bv *BindVar) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

+ type BitOp struct

+ Op string

+ func NewBitOp(left, right sql.Expression, op string) *BitOp

+ func (*BitOp) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

+ func (b *BitOp) DebugString() string

+ func (b *BitOp) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (b *BitOp) IsNullable() bool

+ func (b *BitOp) String() string

+ func (b *BitOp) Type() sql.Type

+ func (b *BitOp) WithChildren(children ...sql.Expression) (sql.Expression, error)

type Case

+ func (c *Case) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type CollatedExpression

+ func (ce *CollatedExpression) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type Convert

+ func (c *Convert) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

+ func (c *Convert) DebugString() string

type DefaultColumn

+ func (*DefaultColumn) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type DistinctExpression

+ func (de *DistinctExpression) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

+ type Div struct

+ func (*Div) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

+ func (d *Div) DebugString() string

+ func (d *Div) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (d *Div) IsNullable() bool

+ func (d *Div) LeftChild() sql.Expression

+ func (d *Div) Operator() string

+ func (d *Div) RightChild() sql.Expression

+ func (d *Div) SetOpCount(i int32)

+ func (d *Div) String() string

+ func (d *Div) Type() sql.Type

+ func (d *Div) WithChildren(children ...sql.Expression) (sql.Expression, error)

type Equals

+ func (e *Equals) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type GetField

+ func (p *GetField) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type GreaterThan

+ func (gt *GreaterThan) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type GreaterThanOrEqual

+ func (gte *GreaterThanOrEqual) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type InTuple

+ func (*InTuple) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

+ type IntDiv struct

+ func (*IntDiv) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

+ func (i *IntDiv) DebugString() string

+ func (i *IntDiv) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (i *IntDiv) IsNullable() bool

+ func (i *IntDiv) LeftChild() sql.Expression

+ func (i *IntDiv) Operator() string

+ func (i *IntDiv) RightChild() sql.Expression

+ func (i *IntDiv) SetOpCount(i2 int32)

+ func (i *IntDiv) String() string

+ func (i *IntDiv) Type() sql.Type

+ func (i *IntDiv) WithChildren(children ...sql.Expression) (sql.Expression, error)

type Interval

+ func (*Interval) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type IsNull

+ func (*IsNull) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type IsTrue

+ func (*IsTrue) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type LessThan

+ func (lt *LessThan) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type LessThanOrEqual

+ func (lte *LessThanOrEqual) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type Like

+ Escape sql.Expression

+ func (l *Like) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type Literal

+ func (lit *Literal) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

+ type Mod struct

+ func (*Mod) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

+ func (m *Mod) DebugString() string

+ func (m *Mod) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (m *Mod) IsNullable() bool

+ func (m *Mod) LeftChild() sql.Expression

+ func (m *Mod) Operator() string

+ func (m *Mod) RightChild() sql.Expression

+ func (m *Mod) SetOpCount(i int32)

+ func (m *Mod) String() string

+ func (m *Mod) Type() sql.Type

+ func (m *Mod) WithChildren(children ...sql.Expression) (sql.Expression, error)

type Not

+ func (*Not) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type NullSafeEquals

+ func (e *NullSafeEquals) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type Or

+ func (*Or) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

+ type ProcedureBlockExitError int

+ func (b ProcedureBlockExitError) Error() string

type ProcedureParam

+ func (pp *ProcedureParam) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

+ type ProcedureReferencable interface

+ WithParamReference func(pRef *ProcedureReference) sql.Node

+ type ProcedureReference struct

+ InnermostScope *procedureScope

+ func NewProcedureReference() *ProcedureReference

+ func (ppr *ProcedureReference) CloseAllCursors(ctx *sql.Context) error

+ func (ppr *ProcedureReference) CloseCursor(ctx *sql.Context, name string) error

+ func (ppr *ProcedureReference) CurrentHeight() int

+ func (ppr *ProcedureReference) FetchCursor(ctx *sql.Context, name string) (sql.Row, sql.Schema, error)

+ func (ppr *ProcedureReference) GetVariableType(name string) sql.Type

+ func (ppr *ProcedureReference) GetVariableValue(name string) (interface{}, error)

+ func (ppr *ProcedureReference) InitializeCursor(name string, selectStmt sql.Node)

+ func (ppr *ProcedureReference) InitializeHandler(stmt sql.Node, returnsExitError bool)

+ func (ppr *ProcedureReference) InitializeVariable(name string, sqlType sql.Type, val interface{}) error

+ func (ppr *ProcedureReference) PopScope(ctx *sql.Context) error

+ func (ppr *ProcedureReference) PushScope()

+ func (ppr *ProcedureReference) SetVariable(name string, val interface{}, valType sql.Type) error

+ func (ppr *ProcedureReference) VariableHasBeenSet(name string) bool

type Regexp

+ func (c *Regexp) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type SetField

+ func (s *SetField) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type Star

+ func (*Star) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type SystemVar

+ func (v *SystemVar) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type UnaryMinus

+ func (*UnaryMinus) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type UnresolvedColumn

+ func (*UnresolvedColumn) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type UnresolvedFunction

+ func (*UnresolvedFunction) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

+ type UnresolvedProcedureParam struct

+ func NewUnresolvedProcedureParam(name string) *UnresolvedProcedureParam

+ func (*UnresolvedProcedureParam) Children() []sql.Expression

+ func (*UnresolvedProcedureParam) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

+ func (*UnresolvedProcedureParam) IsNullable() bool

+ func (*UnresolvedProcedureParam) Resolved() bool

+ func (*UnresolvedProcedureParam) Type() sql.Type

+ func (upp *UnresolvedProcedureParam) Eval(ctx *sql.Context, r sql.Row) (interface{}, error)

+ func (upp *UnresolvedProcedureParam) Name() string

+ func (upp *UnresolvedProcedureParam) String() string

+ func (upp *UnresolvedProcedureParam) WithChildren(children ...sql.Expression) (sql.Expression, error)

type UnresolvedTableFunction

+ func (UnresolvedTableFunction) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

+ func (utf *UnresolvedTableFunction) Name() string

+ func (utf *UnresolvedTableFunction) WithName(s string) sql.Node

type UserVar

+ func (v *UserVar) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type Wrapper

+ func (w *Wrapper) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

type Xor

+ func (*Xor) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte)

v0.14.0

Nov 1, 2022

Changes in this version

+ func ContainsImpreciseComparison(e sql.Expression) bool

+ func GetCollationViaCoercion(expr sql.Expression) (sql.CollationID, int)

+ func GetDecimalPrecisionAndScale(val string) (uint8, uint8)

+ func ResolveCoercibility(leftCollation sql.CollationID, leftCoercibility int, ...) (sql.CollationID, error)

+ type AliasReference struct

+ func NewAliasReference(name string) *AliasReference

+ func (a AliasReference) Children() []sql.Expression

+ func (a AliasReference) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (a AliasReference) IsNullable() bool

+ func (a AliasReference) Name() string

+ func (a AliasReference) Resolved() bool

+ func (a AliasReference) String() string

+ func (a AliasReference) Table() string

+ func (a AliasReference) Type() sql.Type

+ func (a AliasReference) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type CollatedExpression struct

+ func NewCollatedExpression(expr sql.Expression, collation sql.CollationID) *CollatedExpression

+ func (ce *CollatedExpression) Child() sql.Expression

+ func (ce *CollatedExpression) Children() []sql.Expression

+ func (ce *CollatedExpression) DebugString() string

+ func (ce *CollatedExpression) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (ce *CollatedExpression) IsNullable() bool

+ func (ce *CollatedExpression) Resolved() bool

+ func (ce *CollatedExpression) String() string

+ func (ce *CollatedExpression) Type() sql.Type

+ func (ce *CollatedExpression) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type LikeMatcher struct

+ func ConstructLikeMatcher(collation sql.CollationID, pattern string, escape rune) (LikeMatcher, error)

+ func (l LikeMatcher) Match(s string) bool

+ func (l LikeMatcher) String() string

+ type NamedLiteral struct

+ Name string

+ func NewNamedLiteral(name string, value interface{}, fieldType sql.Type) NamedLiteral

+ func (lit NamedLiteral) String() string

v0.12.0

Jun 12, 2022

Changes in this version

+ var ErrInvalidOffset = errors.NewKind("offset must be a non-negative integer; found: %v")

+ var ErrUnresolvedTableFunction = errors.NewKind("unresolved table function")

+ func IsBindVar(e sql.Expression) bool

+ func LiteralToInt(e sql.Expression) (int, error)

+ func NewXor(left, right sql.Expression) sql.Expression

+ func SchemaToGetFields(s sql.Schema) []sql.Expression

type AutoIncrement

+ func NewAutoIncrementForColumn(ctx *sql.Context, table sql.Table, autoCol *sql.Column, given sql.Expression) (*AutoIncrement, error)

type BindVar

+ Typ sql.Type

type Equals

+ func (c *Equals) NullSafeCompare(ctx *sql.Context, row sql.Row) (int, error)

type GetField

+ func ExtractGetField(e sql.Expression) *GetField

+ func (p *GetField) Eval2(ctx *sql.Context, row sql.Row2) (sql.Value, error)

+ func (p *GetField) Type2() sql.Type2

type GreaterThan

+ func (c *GreaterThan) NullSafeCompare(ctx *sql.Context, row sql.Row) (int, error)

type GreaterThanOrEqual

+ func (c *GreaterThanOrEqual) NullSafeCompare(ctx *sql.Context, row sql.Row) (int, error)

+ type HashInTuple struct

+ func NewHashInTuple(left, right sql.Expression) (*HashInTuple, error)

+ func (hit *HashInTuple) DebugString() string

+ func (hit *HashInTuple) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (hit *HashInTuple) String() string

type LessThan

+ func (c *LessThan) NullSafeCompare(ctx *sql.Context, row sql.Row) (int, error)

type LessThanOrEqual

+ func (c *LessThanOrEqual) NullSafeCompare(ctx *sql.Context, row sql.Row) (int, error)

type Literal

+ func (lit *Literal) Eval2(ctx *sql.Context, row sql.Row2) (sql.Value, error)

+ func (lit *Literal) Type2() sql.Type2

type NullSafeEquals

+ func (c *NullSafeEquals) NullSafeCompare(ctx *sql.Context, row sql.Row) (int, error)

+ type NullSafeGreaterThan struct

+ func NewNullSafeGreaterThan(left sql.Expression, right sql.Expression) *NullSafeGreaterThan

+ func (*NullSafeGreaterThan) Type() sql.Type

+ func (c *NullSafeGreaterThan) Compare(ctx *sql.Context, row sql.Row) (int, error)

+ func (c *NullSafeGreaterThan) Left() sql.Expression

+ func (c *NullSafeGreaterThan) NullSafeCompare(ctx *sql.Context, row sql.Row) (int, error)

+ func (c *NullSafeGreaterThan) Right() sql.Expression

+ func (gt *NullSafeGreaterThan) DebugString() string

+ func (gt *NullSafeGreaterThan) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (gt *NullSafeGreaterThan) String() string

+ func (gt *NullSafeGreaterThan) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type NullSafeGreaterThanOrEqual struct

+ func NewNullSafeGreaterThanOrEqual(left sql.Expression, right sql.Expression) *NullSafeGreaterThanOrEqual

+ func (*NullSafeGreaterThanOrEqual) Type() sql.Type

+ func (c *NullSafeGreaterThanOrEqual) Compare(ctx *sql.Context, row sql.Row) (int, error)

+ func (c *NullSafeGreaterThanOrEqual) Left() sql.Expression

+ func (c *NullSafeGreaterThanOrEqual) NullSafeCompare(ctx *sql.Context, row sql.Row) (int, error)

+ func (c *NullSafeGreaterThanOrEqual) Right() sql.Expression

+ func (gte *NullSafeGreaterThanOrEqual) DebugString() string

+ func (gte *NullSafeGreaterThanOrEqual) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (gte *NullSafeGreaterThanOrEqual) String() string

+ func (gte *NullSafeGreaterThanOrEqual) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type NullSafeLessThan struct

+ func NewNullSafeLessThan(left sql.Expression, right sql.Expression) *NullSafeLessThan

+ func (*NullSafeLessThan) Type() sql.Type

+ func (c *NullSafeLessThan) Compare(ctx *sql.Context, row sql.Row) (int, error)

+ func (c *NullSafeLessThan) Left() sql.Expression

+ func (c *NullSafeLessThan) NullSafeCompare(ctx *sql.Context, row sql.Row) (int, error)

+ func (c *NullSafeLessThan) Right() sql.Expression

+ func (lt *NullSafeLessThan) DebugString() string

+ func (lt *NullSafeLessThan) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (lt *NullSafeLessThan) String() string

+ func (lt *NullSafeLessThan) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type NullSafeLessThanOrEqual struct

+ func NewNullSafeLessThanOrEqual(left sql.Expression, right sql.Expression) *NullSafeLessThanOrEqual

+ func (*NullSafeLessThanOrEqual) Type() sql.Type

+ func (c *NullSafeLessThanOrEqual) Compare(ctx *sql.Context, row sql.Row) (int, error)

+ func (c *NullSafeLessThanOrEqual) Left() sql.Expression

+ func (c *NullSafeLessThanOrEqual) NullSafeCompare(ctx *sql.Context, row sql.Row) (int, error)

+ func (c *NullSafeLessThanOrEqual) Right() sql.Expression

+ func (lte *NullSafeLessThanOrEqual) DebugString() string

+ func (lte *NullSafeLessThanOrEqual) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (lte *NullSafeLessThanOrEqual) String() string

+ func (lte *NullSafeLessThanOrEqual) WithChildren(children ...sql.Expression) (sql.Expression, error)

type Regexp

+ func (c *Regexp) NullSafeCompare(ctx *sql.Context, row sql.Row) (int, error)

+ type Sorter2 struct

+ Ctx *sql.Context

+ LastError error

+ Rows []sql.Row2

+ SortFields []sql.SortField

+ func (s *Sorter2) Len() int

+ func (s *Sorter2) Less(i, j int) bool

+ func (s *Sorter2) Swap(i, j int)

+ type TopRowsHeap struct

+ func (h *TopRowsHeap) Less(i, j int) bool

+ func (h *TopRowsHeap) Pop() interface{}

+ func (h *TopRowsHeap) Push(x interface{})

+ func (h *TopRowsHeap) Rows() ([]sql.Row, error)

type UnresolvedColumn

+ func (uc *UnresolvedColumn) Eval2(ctx *sql.Context, row sql.Row2) (sql.Value, error)

+ func (uc *UnresolvedColumn) Type2() sql.Type2

type UnresolvedFunction

+ func (uf *UnresolvedFunction) WithWindow(def *sql.WindowDefinition) *UnresolvedFunction

+ type UnresolvedTableFunction struct

+ Arguments []sql.Expression

+ func NewUnresolvedTableFunction(name string, arguments []sql.Expression) *UnresolvedTableFunction

+ func (utf *UnresolvedTableFunction) Children() []sql.Node

+ func (utf *UnresolvedTableFunction) Database() sql.Database

+ func (utf *UnresolvedTableFunction) Expressions() []sql.Expression

+ func (utf *UnresolvedTableFunction) FunctionName() string

+ func (utf *UnresolvedTableFunction) NewInstance(_ *sql.Context, _ sql.Database, _ []sql.Expression) (sql.Node, error)

+ func (utf *UnresolvedTableFunction) Resolved() bool

+ func (utf *UnresolvedTableFunction) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)

+ func (utf *UnresolvedTableFunction) Schema() sql.Schema

+ func (utf *UnresolvedTableFunction) String() string

+ func (utf *UnresolvedTableFunction) WithChildren(node ...sql.Node) (sql.Node, error)

+ func (utf *UnresolvedTableFunction) WithDatabase(database sql.Database) (sql.Node, error)

+ func (utf *UnresolvedTableFunction) WithExpressions(expression ...sql.Expression) (sql.Node, error)

+ func (utf UnresolvedTableFunction) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool

type UserVar

+ func NewUserVarWithType(name string, t sql.Type) *UserVar

+ type Xor struct

+ func (*Xor) Type() sql.Type

+ func (x *Xor) DebugString() string

+ func (x *Xor) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (x *Xor) String() string

+ func (x *Xor) WithChildren(children ...sql.Expression) (sql.Expression, error)

v0.11.0

Oct 20, 2021

Changes in this version

+ func Clone(expr sql.Expression) (sql.Expression, error)

+ func Dispose(e sql.Expression)

type Tuple

+ func (t Tuple) DebugString() string

v0.10.0

Jun 2, 2021

Changes in this version

type Between

+ func (b *Between) DebugString() string

type Case

+ func (c *Case) DebugString() string

+ type DistinctExpression struct

+ Child sql.Expression

+ func NewDistinctExpression(e sql.Expression) *DistinctExpression

+ func (de *DistinctExpression) Children() []sql.Expression

+ func (de *DistinctExpression) Dispose()

+ func (de *DistinctExpression) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (de *DistinctExpression) IsNullable() bool

+ func (de *DistinctExpression) Resolved() bool

+ func (de *DistinctExpression) String() string

+ func (de *DistinctExpression) Type() sql.Type

+ func (de *DistinctExpression) WithChildren(children ...sql.Expression) (sql.Expression, error)

type Or

+ func (o *Or) DebugString() string

type SystemVar

+ Scope sql.SystemVariableScope

v0.9.0

Apr 2, 2021

Changes in this version

+ func ExpressionsResolved(exprs ...sql.Expression) bool

+ func NewBinary(e sql.Expression) sql.Expression

+ type Binary struct

+ func (b *Binary) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (b *Binary) String() string

+ func (b *Binary) Type() sql.Type

+ func (b *Binary) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type NullSafeEquals struct

+ func NewNullSafeEquals(left sql.Expression, right sql.Expression) *NullSafeEquals

+ func (c *NullSafeEquals) Left() sql.Expression

+ func (c *NullSafeEquals) Right() sql.Expression

+ func (e *NullSafeEquals) Compare(ctx *sql.Context, row sql.Row) (int, error)

+ func (e *NullSafeEquals) DebugString() string

+ func (e *NullSafeEquals) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (e *NullSafeEquals) String() string

+ func (e *NullSafeEquals) Type() sql.Type

+ func (e *NullSafeEquals) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type ProcedureParam struct

+ func NewProcedureParam(name string) *ProcedureParam

+ func (*ProcedureParam) Children() []sql.Expression

+ func (*ProcedureParam) IsNullable() bool

+ func (*ProcedureParam) Resolved() bool

+ func (pp *ProcedureParam) Eval(ctx *sql.Context, r sql.Row) (interface{}, error)

+ func (pp *ProcedureParam) Name() string

+ func (pp *ProcedureParam) Set(val interface{}, valType sql.Type) error

+ func (pp *ProcedureParam) String() string

+ func (pp *ProcedureParam) Type() sql.Type

+ func (pp *ProcedureParam) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ func (pp *ProcedureParam) WithParamReference(pRef *ProcedureParamReference) *ProcedureParam

+ type ProcedureParamReference struct

+ func NewProcedureParamReference() *ProcedureParamReference

+ func (ppr *ProcedureParamReference) Get(name string) (interface{}, error)

+ func (ppr *ProcedureParamReference) GetType(name string) sql.Type

+ func (ppr *ProcedureParamReference) HasBeenSet(name string) bool

+ func (ppr *ProcedureParamReference) Initialize(name string, sqlType sql.Type, val interface{}) error

+ func (ppr *ProcedureParamReference) Set(name string, val interface{}, valType sql.Type) error

+ type Sorter struct

+ Ctx *sql.Context

+ LastError error

+ Rows []sql.Row

+ SortFields []sql.SortField

+ func (s *Sorter) Len() int

+ func (s *Sorter) Less(i, j int) bool

+ func (s *Sorter) Swap(i, j int)

type UnresolvedFunction

+ Window *sql.Window

+ func (uf *UnresolvedFunction) DebugString() string

v0.8.0

Feb 1, 2021

Changes in this version

+ const ConvertToBinary

+ const ConvertToChar

+ const ConvertToDate

+ const ConvertToDatetime

+ const ConvertToDecimal

+ const ConvertToDouble

+ const ConvertToJSON

+ const ConvertToNChar

+ const ConvertToReal

+ const ConvertToSigned

+ const ConvertToTime

+ const ConvertToUnsigned

+ const IsFalseStr

+ const IsTrueStr

+ var ErrAutoIncrementUnsupported = errors.NewKind("table %s does not support AUTO_INCREMENT columns")

+ var ErrConvertExpression = errors.NewKind("expression '%v': couldn't convert to %v")

+ var ErrIndexOutOfBounds = errors.NewKind("unable to find field with index %d in row of %d columns")

+ var ErrInvalidOperandColumns = errors.NewKind("operand should have %d columns, but has %d")

+ var ErrInvalidRegexp = errors.NewKind("Invalid regular expression: %s")

+ var ErrNilOperand = errors.NewKind("nil operand found in comparison")

+ var ErrNoAutoIncrementCols = errors.NewKind("table %s has no AUTO_INCREMENT columns")

+ var ErrUnsupportedInOperand = errors.NewKind("right operand in IN operation must be tuple, but is %T")

+ func ExpressionToColumn(e sql.Expression) *sql.Column

+ func IsBinary(e sql.Expression) bool

+ func IsUnary(e sql.Expression) bool

+ func JoinAnd(exprs ...sql.Expression) sql.Expression

+ func NewAnd(left, right sql.Expression) sql.Expression

+ func NewBindVar(name string) sql.Expression

+ func NewLike(left, right sql.Expression) sql.Expression

+ func NewNotInTuple(left sql.Expression, right sql.Expression) sql.Expression

+ func NewOr(left, right sql.Expression) sql.Expression

+ func NewSetField(left, expr sql.Expression) sql.Expression

+ func TransformUp(e sql.Expression, f sql.TransformExprFunc) (sql.Expression, error)

+ func TransformUpWithNode(n sql.Node, e sql.Expression, f TransformExprWithNodeFunc) (sql.Expression, error)

+ func WrapExpressions(exprs ...sql.Expression) []sql.Expression

+ type Alias struct

+ func NewAlias(name string, expr sql.Expression) *Alias

+ func (e *Alias) DebugString() string

+ func (e *Alias) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (e *Alias) Name() string

+ func (e *Alias) String() string

+ func (e *Alias) Type() sql.Type

+ func (e *Alias) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type And struct

+ func (*And) Type() sql.Type

+ func (a *And) DebugString() string

+ func (a *And) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (a *And) String() string

+ func (a *And) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type Arithmetic struct

+ Op string

+ func NewArithmetic(left, right sql.Expression, op string) *Arithmetic

+ func NewBitAnd(left, right sql.Expression) *Arithmetic

+ func NewBitOr(left, right sql.Expression) *Arithmetic

+ func NewBitXor(left, right sql.Expression) *Arithmetic

+ func NewDiv(left, right sql.Expression) *Arithmetic

+ func NewIncrement(left sql.Expression) *Arithmetic

+ func NewIntDiv(left, right sql.Expression) *Arithmetic

+ func NewMinus(left, right sql.Expression) *Arithmetic

+ func NewMod(left, right sql.Expression) *Arithmetic

+ func NewMult(left, right sql.Expression) *Arithmetic

+ func NewPlus(left, right sql.Expression) *Arithmetic

+ func NewShiftLeft(left, right sql.Expression) *Arithmetic

+ func NewShiftRight(left, right sql.Expression) *Arithmetic

+ func (a *Arithmetic) DebugString() string

+ func (a *Arithmetic) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (a *Arithmetic) IsNullable() bool

+ func (a *Arithmetic) String() string

+ func (a *Arithmetic) Type() sql.Type

+ func (a *Arithmetic) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type AutoIncrement struct

+ func NewAutoIncrement(ctx *sql.Context, table sql.Table, given sql.Expression) (*AutoIncrement, error)

+ func (i *AutoIncrement) Children() []sql.Expression

+ func (i *AutoIncrement) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (i *AutoIncrement) IsNullable() bool

+ func (i *AutoIncrement) String() string

+ func (i *AutoIncrement) Type() sql.Type

+ func (i *AutoIncrement) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type Between struct

+ Lower sql.Expression

+ Upper sql.Expression

+ Val sql.Expression

+ func NewBetween(val, lower, upper sql.Expression) *Between

+ func (*Between) Type() sql.Type

+ func (b *Between) Children() []sql.Expression

+ func (b *Between) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (b *Between) IsNullable() bool

+ func (b *Between) Resolved() bool

+ func (b *Between) String() string

+ func (b *Between) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type BinaryExpression struct

+ Left sql.Expression

+ Right sql.Expression

+ func (p *BinaryExpression) Children() []sql.Expression

+ func (p *BinaryExpression) IsNullable() bool

+ func (p *BinaryExpression) Resolved() bool

+ type BindVar struct

+ Name string

+ func (bv *BindVar) Children() []sql.Expression

+ func (bv *BindVar) Eval(*sql.Context, sql.Row) (interface{}, error)

+ func (bv *BindVar) IsNullable() bool

+ func (bv *BindVar) Resolved() bool

+ func (bv *BindVar) String() string

+ func (bv *BindVar) Type() sql.Type

+ func (bv *BindVar) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type Case struct

+ Branches []CaseBranch

+ Else sql.Expression

+ Expr sql.Expression

+ func NewCase(expr sql.Expression, branches []CaseBranch, elseExpr sql.Expression) *Case

+ func (c *Case) Children() []sql.Expression

+ func (c *Case) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (c *Case) IsNullable() bool

+ func (c *Case) Resolved() bool

+ func (c *Case) String() string

+ func (c *Case) Type() sql.Type

+ func (c *Case) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type CaseBranch struct

+ Cond sql.Expression

+ Value sql.Expression

+ type Comparer interface

+ Compare func(ctx *sql.Context, row sql.Row) (int, error)

+ Left func() sql.Expression

+ Right func() sql.Expression

+ type Convert struct

+ func NewConvert(expr sql.Expression, castToType string) *Convert

+ func (c *Convert) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (c *Convert) IsNullable() bool

+ func (c *Convert) String() string

+ func (c *Convert) Type() sql.Type

+ func (c *Convert) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type DefaultColumn struct

+ func NewDefaultColumn(name string) *DefaultColumn

+ func (*DefaultColumn) Children() []sql.Expression

+ func (*DefaultColumn) Eval(ctx *sql.Context, r sql.Row) (interface{}, error)

+ func (*DefaultColumn) IsNullable() bool

+ func (*DefaultColumn) Resolved() bool

+ func (*DefaultColumn) Type() sql.Type

+ func (c *DefaultColumn) Name() string

+ func (c *DefaultColumn) String() string

+ func (c *DefaultColumn) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type Equals struct

+ func NewEquals(left sql.Expression, right sql.Expression) *Equals

+ func (*Equals) Type() sql.Type

+ func (c *Equals) Compare(ctx *sql.Context, row sql.Row) (int, error)

+ func (c *Equals) Left() sql.Expression

+ func (c *Equals) Right() sql.Expression

+ func (e *Equals) DebugString() string

+ func (e *Equals) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (e *Equals) String() string

+ func (e *Equals) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type GetField struct

+ func NewGetField(index int, fieldType sql.Type, fieldName string, nullable bool) *GetField

+ func NewGetFieldWithTable(index int, fieldType sql.Type, table, fieldName string, nullable bool) *GetField

+ func (*GetField) Children() []sql.Expression

+ func (p *GetField) DebugString() string

+ func (p *GetField) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (p *GetField) Index() int

+ func (p *GetField) IsNullable() bool

+ func (p *GetField) Name() string

+ func (p *GetField) Resolved() bool

+ func (p *GetField) String() string

+ func (p *GetField) Table() string

+ func (p *GetField) Type() sql.Type

+ func (p *GetField) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ func (p *GetField) WithIndex(n int) sql.Expression

+ func (p *GetField) WithName(name string) *GetField

+ func (p *GetField) WithTable(table string) *GetField

+ type GreaterThan struct

+ func NewGreaterThan(left sql.Expression, right sql.Expression) *GreaterThan

+ func (*GreaterThan) Type() sql.Type

+ func (c *GreaterThan) Compare(ctx *sql.Context, row sql.Row) (int, error)

+ func (c *GreaterThan) Left() sql.Expression

+ func (c *GreaterThan) Right() sql.Expression

+ func (gt *GreaterThan) DebugString() string

+ func (gt *GreaterThan) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (gt *GreaterThan) String() string

+ func (gt *GreaterThan) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type GreaterThanOrEqual struct

+ func NewGreaterThanOrEqual(left sql.Expression, right sql.Expression) *GreaterThanOrEqual

+ func (*GreaterThanOrEqual) Type() sql.Type

+ func (c *GreaterThanOrEqual) Compare(ctx *sql.Context, row sql.Row) (int, error)

+ func (c *GreaterThanOrEqual) Left() sql.Expression

+ func (c *GreaterThanOrEqual) Right() sql.Expression

+ func (gte *GreaterThanOrEqual) DebugString() string

+ func (gte *GreaterThanOrEqual) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (gte *GreaterThanOrEqual) String() string

+ func (gte *GreaterThanOrEqual) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type InTuple struct

+ func NewInTuple(left sql.Expression, right sql.Expression) *InTuple

+ func (in *InTuple) Children() []sql.Expression

+ func (in *InTuple) Compare(ctx *sql.Context, row sql.Row) (int, error)

+ func (in *InTuple) DebugString() string

+ func (in *InTuple) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (in *InTuple) Left() sql.Expression

+ func (in *InTuple) Right() sql.Expression

+ func (in *InTuple) String() string

+ func (in *InTuple) Type() sql.Type

+ func (in *InTuple) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type Interval struct

+ Unit string

+ func NewInterval(child sql.Expression, unit string) *Interval

+ func (i *Interval) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (i *Interval) EvalDelta(ctx *sql.Context, row sql.Row) (*TimeDelta, error)

+ func (i *Interval) IsNullable() bool

+ func (i *Interval) String() string

+ func (i *Interval) Type() sql.Type

+ func (i *Interval) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type IsNull struct

+ func NewIsNull(child sql.Expression) *IsNull

+ func (e *IsNull) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (e *IsNull) IsNullable() bool

+ func (e *IsNull) Type() sql.Type

+ func (e *IsNull) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ func (e IsNull) DebugString() string

+ func (e IsNull) String() string

+ type IsTrue struct

+ func NewIsFalse(child sql.Expression) *IsTrue

+ func NewIsTrue(child sql.Expression) *IsTrue

+ func (*IsTrue) IsNullable() bool

+ func (*IsTrue) Type() sql.Type

+ func (e *IsTrue) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (e *IsTrue) String() string

+ func (e *IsTrue) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type LessThan struct

+ func NewLessThan(left sql.Expression, right sql.Expression) *LessThan

+ func (*LessThan) Type() sql.Type

+ func (c *LessThan) Compare(ctx *sql.Context, row sql.Row) (int, error)

+ func (c *LessThan) Left() sql.Expression

+ func (c *LessThan) Right() sql.Expression

+ func (lt *LessThan) DebugString() string

+ func (lt *LessThan) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (lt *LessThan) String() string

+ func (lt *LessThan) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type LessThanOrEqual struct

+ func NewLessThanOrEqual(left sql.Expression, right sql.Expression) *LessThanOrEqual

+ func (*LessThanOrEqual) Type() sql.Type

+ func (c *LessThanOrEqual) Compare(ctx *sql.Context, row sql.Row) (int, error)

+ func (c *LessThanOrEqual) Left() sql.Expression

+ func (c *LessThanOrEqual) Right() sql.Expression

+ func (lte *LessThanOrEqual) DebugString() string

+ func (lte *LessThanOrEqual) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (lte *LessThanOrEqual) String() string

+ func (lte *LessThanOrEqual) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type Like struct

+ func (l *Like) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (l *Like) String() string

+ func (l *Like) Type() sql.Type

+ func (l *Like) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type Literal struct

+ func NewLiteral(value interface{}, fieldType sql.Type) *Literal

+ func (*Literal) Children() []sql.Expression

+ func (p *Literal) DebugString() string

+ func (p *Literal) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (p *Literal) IsNullable() bool

+ func (p *Literal) Resolved() bool

+ func (p *Literal) String() string

+ func (p *Literal) Type() sql.Type

+ func (p *Literal) Value() interface{}

+ func (p *Literal) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type NaryExpression struct

+ ChildExpressions []sql.Expression

+ func (n *NaryExpression) Children() []sql.Expression

+ func (n *NaryExpression) IsNullable() bool

+ func (n *NaryExpression) Resolved() bool

+ type Not struct

+ func NewNot(child sql.Expression) *Not

+ func (e *Not) DebugString() string

+ func (e *Not) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (e *Not) String() string

+ func (e *Not) Type() sql.Type

+ func (e *Not) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type Or struct

+ func (*Or) Type() sql.Type

+ func (o *Or) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (o *Or) String() string

+ func (o *Or) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type Regexp struct

+ func NewRegexp(left sql.Expression, right sql.Expression) *Regexp

+ func (*Regexp) Type() sql.Type

+ func (c *Regexp) Compare(ctx *sql.Context, row sql.Row) (int, error)

+ func (c *Regexp) Left() sql.Expression

+ func (c *Regexp) Right() sql.Expression

+ func (re *Regexp) DebugString() string

+ func (re *Regexp) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (re *Regexp) String() string

+ func (re *Regexp) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type SetField struct

+ func (s *SetField) DebugString() string

+ func (s *SetField) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (s *SetField) String() string

+ func (s *SetField) Type() sql.Type

+ func (s *SetField) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type Star struct

+ Table string

+ func NewQualifiedStar(table string) *Star

+ func NewStar() *Star

+ func (*Star) Children() []sql.Expression

+ func (*Star) Eval(ctx *sql.Context, r sql.Row) (interface{}, error)

+ func (*Star) IsNullable() bool

+ func (*Star) Resolved() bool

+ func (*Star) Type() sql.Type

+ func (s *Star) String() string

+ func (s *Star) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type SystemVar struct

+ Name string

+ func NewSystemVar(name string, typ sql.Type) *SystemVar

+ func (v *SystemVar) Children() []sql.Expression

+ func (v *SystemVar) DebugString() string

+ func (v *SystemVar) Eval(ctx *sql.Context, _ sql.Row) (interface{}, error)

+ func (v *SystemVar) IsNullable() bool

+ func (v *SystemVar) Resolved() bool

+ func (v *SystemVar) String() string

+ func (v *SystemVar) Type() sql.Type

+ func (v *SystemVar) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type TimeDelta struct

+ Days int64

+ Hours int64

+ Microseconds int64

+ Minutes int64

+ Months int64

+ Seconds int64

+ Years int64

+ func (td TimeDelta) Add(t time.Time) time.Time

+ func (td TimeDelta) Sub(t time.Time) time.Time

+ type TransformExprWithNodeFunc func(sql.Node, sql.Expression) (sql.Expression, error)

+ type Tuple []sql.Expression

+ func NewTuple(exprs ...sql.Expression) Tuple

+ func (t Tuple) Children() []sql.Expression

+ func (t Tuple) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (t Tuple) IsNullable() bool

+ func (t Tuple) Resolved() bool

+ func (t Tuple) String() string

+ func (t Tuple) Type() sql.Type

+ func (t Tuple) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type UnaryExpression struct

+ Child sql.Expression

+ func (p *UnaryExpression) Children() []sql.Expression

+ func (p *UnaryExpression) IsNullable() bool

+ func (p *UnaryExpression) Resolved() bool

+ type UnaryMinus struct

+ func NewUnaryMinus(child sql.Expression) *UnaryMinus

+ func (e *UnaryMinus) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (e *UnaryMinus) String() string

+ func (e *UnaryMinus) Type() sql.Type

+ func (e *UnaryMinus) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type UnresolvedColumn struct

+ func NewUnresolvedColumn(name string) *UnresolvedColumn

+ func NewUnresolvedQualifiedColumn(table, name string) *UnresolvedColumn

+ func (*UnresolvedColumn) Children() []sql.Expression

+ func (*UnresolvedColumn) Eval(ctx *sql.Context, r sql.Row) (interface{}, error)

+ func (*UnresolvedColumn) IsNullable() bool

+ func (*UnresolvedColumn) Resolved() bool

+ func (*UnresolvedColumn) Type() sql.Type

+ func (uc *UnresolvedColumn) Name() string

+ func (uc *UnresolvedColumn) String() string

+ func (uc *UnresolvedColumn) Table() string

+ func (uc *UnresolvedColumn) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type UnresolvedFunction struct

+ Arguments []sql.Expression

+ IsAggregate bool

+ func NewUnresolvedFunction(name string, agg bool, arguments ...sql.Expression) *UnresolvedFunction

+ func (*UnresolvedFunction) Eval(ctx *sql.Context, r sql.Row) (interface{}, error)

+ func (*UnresolvedFunction) IsNullable() bool

+ func (*UnresolvedFunction) Resolved() bool

+ func (*UnresolvedFunction) Type() sql.Type

+ func (uf *UnresolvedFunction) Children() []sql.Expression

+ func (uf *UnresolvedFunction) Name() string

+ func (uf *UnresolvedFunction) String() string

+ func (uf *UnresolvedFunction) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type UserVar struct

+ Name string

+ func NewUserVar(name string) *UserVar

+ func (v *UserVar) Children() []sql.Expression

+ func (v *UserVar) DebugString() string

+ func (v *UserVar) Eval(ctx *sql.Context, _ sql.Row) (interface{}, error)

+ func (v *UserVar) IsNullable() bool

+ func (v *UserVar) Resolved() bool

+ func (v *UserVar) String() string

+ func (v *UserVar) Type() sql.Type

+ func (v *UserVar) WithChildren(children ...sql.Expression) (sql.Expression, error)

+ type Wrapper struct

+ func WrapExpression(expr sql.Expression) *Wrapper

+ func (w *Wrapper) Children() []sql.Expression

+ func (w *Wrapper) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)

+ func (w *Wrapper) IsNullable() bool

+ func (w *Wrapper) Resolved() bool

+ func (w *Wrapper) String() string

+ func (w *Wrapper) Type() sql.Type

+ func (w *Wrapper) Unwrap() sql.Expression

+ func (w *Wrapper) WithChildren(children ...sql.Expression) (sql.Expression, error)

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL