Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

function

package

Go to main page

Versions in this module

v0

v0.5.1

Mar 5, 2019

v0.5.0

Feb 7, 2019

v0.4.0

Feb 12, 2019

v0.3.0

Dec 17, 2018

Changes in this version

+ func NewIfNull(ex, value sql.Expression) sql.Expression

+ func NewNow() sql.Expression

+ func NewNullIf(ex1, ex2 sql.Expression) sql.Expression

+ type IfNull struct

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

+ func (f *IfNull) IsNullable() bool

+ func (f *IfNull) String() string

+ func (f *IfNull) TransformUp(fn sql.TransformExprFunc) (sql.Expression, error)

+ func (f *IfNull) Type() sql.Type

+ type Now struct

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

+ func (*Now) IsNullable() bool

+ func (*Now) Resolved() bool

+ func (*Now) String() string

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

+ func (n *Now) Eval(*sql.Context, sql.Row) (interface{}, error)

+ func (n *Now) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

+ type NullIf struct

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

+ func (f *NullIf) IsNullable() bool

+ func (f *NullIf) String() string

+ func (f *NullIf) TransformUp(fn sql.TransformExprFunc) (sql.Expression, error)

+ func (f *NullIf) Type() sql.Type

v0.2.0

Nov 15, 2018

Changes in this version

+ var ErrDivisionByZero = errors.NewKind("division by zero")

+ var ErrInvalidArgumentForLogarithm = errors.NewKind("invalid argument value for logarithm: %v")

+ var ErrNegativeRepeatCount = errors.NewKind("negative Repeat count: %v")

+ func NewCeil(num sql.Expression) sql.Expression

+ func NewCoalesce(args ...sql.Expression) (sql.Expression, error)

+ func NewConcatWithSeparator(args ...sql.Expression) (sql.Expression, error)

+ func NewConnectionID() sql.Expression

+ func NewDatabase(c *sql.Catalog) func() sql.Expression

+ func NewDayOfWeek(date sql.Expression) sql.Expression

+ func NewFloor(num sql.Expression) sql.Expression

+ func NewJSONExtract(args ...sql.Expression) (sql.Expression, error)

+ func NewLog(args ...sql.Expression) (sql.Expression, error)

+ func NewLogBase(base float64, e sql.Expression) sql.Expression

+ func NewLogBaseFunc(base float64) func(e sql.Expression) sql.Expression

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

+ func NewPad(pType padType, args ...sql.Expression) (sql.Expression, error)

+ func NewPadFunc(pType padType) func(e ...sql.Expression) (sql.Expression, error)

+ func NewPower(e1, e2 sql.Expression) sql.Expression

+ func NewRepeat(str sql.Expression, count sql.Expression) sql.Expression

+ func NewReplace(str sql.Expression, fromStr sql.Expression, toStr sql.Expression) sql.Expression

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

+ func NewRound(args ...sql.Expression) (sql.Expression, error)

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

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

+ func NewTrim(tType trimType, str sql.Expression) sql.Expression

+ func NewTrimFunc(tType trimType) func(e sql.Expression) sql.Expression

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

+ func NewWeekday(date sql.Expression) sql.Expression

+ type Ceil struct

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

+ func (c *Ceil) String() string

+ func (c *Ceil) TransformUp(fn sql.TransformExprFunc) (sql.Expression, error)

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

+ type Coalesce struct

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

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

+ func (c *Coalesce) IsNullable() bool

+ func (c *Coalesce) Resolved() bool

+ func (c *Coalesce) String() string

+ func (c *Coalesce) TransformUp(fn sql.TransformExprFunc) (sql.Expression, error)

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

+ type ConcatWithSeparator struct

+ func (f *ConcatWithSeparator) Children() []sql.Expression

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

+ func (f *ConcatWithSeparator) IsNullable() bool

+ func (f *ConcatWithSeparator) Resolved() bool

+ func (f *ConcatWithSeparator) String() string

+ func (f *ConcatWithSeparator) TransformUp(fn sql.TransformExprFunc) (sql.Expression, error)

+ func (f *ConcatWithSeparator) Type() sql.Type

+ type ConnectionID struct

+ func (ConnectionID) Children() []sql.Expression

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

+ func (ConnectionID) IsNullable() bool

+ func (ConnectionID) Resolved() bool

+ func (ConnectionID) String() string

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

+ func (ConnectionID) Type() sql.Type

+ type Database struct

+ func (*Database) String() string

+ func (db *Database) Children() []sql.Expression

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

+ func (db *Database) IsNullable() bool

+ func (db *Database) Resolved() bool

+ func (db *Database) TransformUp(fn sql.TransformExprFunc) (sql.Expression, error)

+ func (db *Database) Type() sql.Type

+ type DayOfWeek struct

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

+ func (d *DayOfWeek) String() string

+ func (d *DayOfWeek) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

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

+ type Floor struct

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

+ func (f *Floor) String() string

+ func (f *Floor) TransformUp(fn sql.TransformExprFunc) (sql.Expression, error)

+ func (f *Floor) Type() sql.Type

+ type JSONExtract struct

+ JSON sql.Expression

+ Paths []sql.Expression

+ func (j *JSONExtract) Children() []sql.Expression

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

+ func (j *JSONExtract) IsNullable() bool

+ func (j *JSONExtract) Resolved() bool

+ func (j *JSONExtract) String() string

+ func (j *JSONExtract) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

+ func (j *JSONExtract) Type() sql.Type

+ type Log struct

+ func (l *Log) Children() []sql.Expression

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

+ func (l *Log) IsNullable() bool

+ func (l *Log) String() string

+ func (l *Log) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

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

+ type LogBase struct

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

+ func (l *LogBase) IsNullable() bool

+ func (l *LogBase) String() string

+ func (l *LogBase) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

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

+ type Lower struct

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

+ func (l *Lower) String() string

+ func (l *Lower) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

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

+ type Pad struct

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

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

+ func (p *Pad) IsNullable() bool

+ func (p *Pad) Resolved() bool

+ func (p *Pad) String() string

+ func (p *Pad) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

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

+ type Power struct

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

+ func (p *Power) IsNullable() bool

+ func (p *Power) String() string

+ func (p *Power) TransformUp(fn sql.TransformExprFunc) (sql.Expression, error)

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

+ type Repeat struct

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

+ func (r *Repeat) String() string

+ func (r *Repeat) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

+ func (r *Repeat) Type() sql.Type

+ type Replace struct

+ func (r *Replace) Children() []sql.Expression

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

+ func (r *Replace) IsNullable() bool

+ func (r *Replace) Resolved() bool

+ func (r *Replace) String() string

+ func (r *Replace) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

+ func (r *Replace) Type() sql.Type

+ type Reverse struct

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

+ func (r *Reverse) String() string

+ func (r *Reverse) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

+ func (r *Reverse) Type() sql.Type

+ type Round struct

+ func (r *Round) Children() []sql.Expression

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

+ func (r *Round) IsNullable() bool

+ func (r *Round) Resolved() bool

+ func (r *Round) String() string

+ func (r *Round) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

+ func (r *Round) Type() sql.Type

+ type Soundex struct

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

+ func (s *Soundex) String() string

+ func (s *Soundex) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

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

+ type Sqrt struct

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

+ func (s *Sqrt) IsNullable() bool

+ func (s *Sqrt) String() string

+ func (s *Sqrt) TransformUp(fn sql.TransformExprFunc) (sql.Expression, error)

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

+ type Trim struct

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

+ func (t *Trim) IsNullable() bool

+ func (t *Trim) String() string

+ func (t *Trim) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

+ func (t *Trim) Type() sql.Type

+ type Upper struct

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

+ func (u *Upper) String() string

+ func (u *Upper) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

+ func (u *Upper) Type() sql.Type

+ type Weekday struct

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

+ func (d *Weekday) String() string

+ func (d *Weekday) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

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

v0.1.1

Oct 19, 2018

v0.1.0

Oct 17, 2018

Changes in this version

+ var Defaults = sql.Functions

+ var ErrConcatArrayWithOthers = errors.NewKind("can't concat a string array with any other elements")

+ func NewArrayLength(array sql.Expression) sql.Expression

+ func NewConcat(args ...sql.Expression) (sql.Expression, error)

+ func NewDay(date sql.Expression) sql.Expression

+ func NewDayOfYear(date sql.Expression) sql.Expression

+ func NewHour(date sql.Expression) sql.Expression

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

+ func NewMinute(date sql.Expression) sql.Expression

+ func NewMonth(date sql.Expression) sql.Expression

+ func NewSecond(date sql.Expression) sql.Expression

+ func NewSplit(str, delimiter sql.Expression) sql.Expression

+ func NewSubstring(args ...sql.Expression) (sql.Expression, error)

+ func NewVersion(versionPostfix string) func(...sql.Expression) (sql.Expression, error)

+ func NewYear(date sql.Expression) sql.Expression

+ type ArrayLength struct

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

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

+ func (f *ArrayLength) String() string

+ func (f *ArrayLength) TransformUp(fn sql.TransformExprFunc) (sql.Expression, error)

+ type Concat struct

+ func (f *Concat) Children() []sql.Expression

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

+ func (f *Concat) IsNullable() bool

+ func (f *Concat) Resolved() bool

+ func (f *Concat) String() string

+ func (f *Concat) TransformUp(fn sql.TransformExprFunc) (sql.Expression, error)

+ func (f *Concat) Type() sql.Type

+ type Day struct

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

+ func (d *Day) String() string

+ func (d *Day) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

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

+ type DayOfYear struct

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

+ func (d *DayOfYear) String() string

+ func (d *DayOfYear) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

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

+ type Hour struct

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

+ func (h *Hour) String() string

+ func (h *Hour) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

+ func (h *Hour) Type() sql.Type

+ type IsBinary struct

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

+ func (ib *IsBinary) String() string

+ func (ib *IsBinary) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

+ func (ib *IsBinary) Type() sql.Type

+ type Minute struct

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

+ func (m *Minute) String() string

+ func (m *Minute) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

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

+ type Month struct

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

+ func (m *Month) String() string

+ func (m *Month) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

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

+ type Second struct

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

+ func (s *Second) String() string

+ func (s *Second) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

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

+ type Split struct

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

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

+ func (f *Split) IsNullable() bool

+ func (f *Split) String() string

+ func (f *Split) TransformUp(fn sql.TransformExprFunc) (sql.Expression, error)

+ type Substring struct

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

+ func (s *Substring) Children() []sql.Expression

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

+ func (s *Substring) IsNullable() bool

+ func (s *Substring) Resolved() bool

+ func (s *Substring) String() string

+ func (s *Substring) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

+ type Version string

+ func (f Version) Children() []sql.Expression

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

+ func (f Version) IsNullable() bool

+ func (f Version) Resolved() bool

+ func (f Version) String() string

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

+ func (f Version) Type() sql.Type

+ type Year struct

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

+ func (y *Year) String() string

+ func (y *Year) TransformUp(f sql.TransformExprFunc) (sql.Expression, error)

+ func (y *Year) Type() sql.Type