builder

package
v0.0.0-...-8fc1c82 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jul 1, 2018 License: BSD-3-Clause, BSD-3-Clause Imports: 5 Imported by: 0

README

SQL builder

Package builder is a lightweight and fast SQL builder for Go and XORM.

Make sure you have installed Go 1.1+ and then:

go get github.com/coscms/xorm/builder

Insert

sql, args, err := Insert(Eq{"c": 1, "d": 2}).Into("table1").ToSQL()

Select

sql, args, err := Select("c, d").From("table1").Where(Eq{"a": 1}).ToSQL()

sql, args, err = Select("c, d").From("table1").LeftJoin("table2", Eq{"table1.id": 1}.And(Lt{"table2.id": 3})).
		RightJoin("table3", "table2.id = table3.tid").Where(Eq{"a": 1}).ToSQL()

Update

sql, args, err := Update(Eq{"a": 2}).From("table1").Where(Eq{"a": 1}).ToSQL()

Delete

sql, args, err := Delete(Eq{"a": 1}).From("table1").ToSQL()

Conditions

  • Eq is a redefine of a map, you can give one or more conditions to Eq
import . "github.com/coscms/xorm/builder"

sql, args, _ := ToSQL(Eq{"a":1})
// a=? [1]
sql, args, _ := ToSQL(Eq{"b":"c"}.And(Eq{"c": 0}))
// b=? AND c=? ["c", 0]
sql, args, _ := ToSQL(Eq{"b":"c", "c":0})
// b=? AND c=? ["c", 0]
sql, args, _ := ToSQL(Eq{"b":"c"}.Or(Eq{"b":"d"}))
// b=? OR b=? ["c", "d"]
sql, args, _ := ToSQL(Eq{"b": []string{"c", "d"}})
// b IN (?,?) ["c", "d"]
sql, args, _ := ToSQL(Eq{"b": 1, "c":[]int{2, 3}})
// b=? AND c IN (?,?) [1, 2, 3]
  • Neq is the same to Eq
import . "github.com/coscms/xorm/builder"

sql, args, _ := ToSQL(Neq{"a":1})
// a<>? [1]
sql, args, _ := ToSQL(Neq{"b":"c"}.And(Neq{"c": 0}))
// b<>? AND c<>? ["c", 0]
sql, args, _ := ToSQL(Neq{"b":"c", "c":0})
// b<>? AND c<>? ["c", 0]
sql, args, _ := ToSQL(Neq{"b":"c"}.Or(Neq{"b":"d"}))
// b<>? OR b<>? ["c", "d"]
sql, args, _ := ToSQL(Neq{"b": []string{"c", "d"}})
// b NOT IN (?,?) ["c", "d"]
sql, args, _ := ToSQL(Neq{"b": 1, "c":[]int{2, 3}})
// b<>? AND c NOT IN (?,?) [1, 2, 3]
  • Gt, Gte, Lt, Lte
import . "github.com/coscms/xorm/builder"

sql, args, _ := ToSQL(Gt{"a", 1}.And(Gte{"b", 2}))
// a>? AND b>=? [1, 2]
sql, args, _ := ToSQL(Lt{"a", 1}.Or(Lte{"b", 2}))
// a<? OR b<=? [1, 2]
  • Like
import . "github.com/coscms/xorm/builder"

sql, args, _ := ToSQL(Like{"a", "c"})
// a LIKE ? [%c%]
  • Expr you can customerize your sql with Expr
import . "github.com/coscms/xorm/builder"

sql, args, _ := ToSQL(Expr("a = ? ", 1))
// a = ? [1]
sql, args, _ := ToSQL(Eq{"a": Expr("select id from table where c = ?", 1)})
// a=(select id from table where c = ?) [1]
  • In and NotIn
import . "github.com/coscms/xorm/builder"

sql, args, _ := ToSQL(In("a", 1, 2, 3))
// a IN (?,?,?) [1,2,3]
sql, args, _ := ToSQL(In("a", []int{1, 2, 3}))
// a IN (?,?,?) [1,2,3]
sql, args, _ := ToSQL(In("a", Expr("select id from b where c = ?", 1))))
// a IN (select id from b where c = ?) [1]
  • IsNull and NotNull
import . "github.com/coscms/xorm/builder"

sql, args, _ := ToSQL(IsNull{"a"})
// a IS NULL []
sql, args, _ := ToSQL(NotNull{"b"})
	// b IS NOT NULL []
  • And(conds ...Cond), And can connect one or more condtions via And
import . "github.com/coscms/xorm/builder"

sql, args, _ := ToSQL(And(Eq{"a":1}, Like{"b", "c"}, Neq{"d", 2}))
// a=? AND b LIKE ? AND d<>? [1, %c%, 2]
  • Or(conds ...Cond), Or can connect one or more conditions via Or
import . "github.com/coscms/xorm/builder"

sql, args, _ := ToSQL(Or(Eq{"a":1}, Like{"b", "c"}, Neq{"d", 2}))
// a=? OR b LIKE ? OR d<>? [1, %c%, 2]
sql, args, _ := ToSQL(Or(Eq{"a":1}, And(Like{"b", "c"}, Neq{"d", 2})))
// a=? OR (b LIKE ? AND d<>?) [1, %c%, 2]
  • Between
import . "github.com/coscms/xorm/builder"

sql, args, _ := ToSQL(Between{"a", 1, 2})
// a BETWEEN 1 AND 2
  • Define yourself conditions

Since Cond is an interface.

type Cond interface {
	WriteTo(Writer) error
	And(...Cond) Cond
	Or(...Cond) Cond
	IsValid() bool
}

You can define yourself conditions and compose with other Cond.

Documentation

Overview

Package builder is a simple and powerful sql builder for Go.

Make sure you have installed Go 1.1+ and then:

go get github.com/coscms/xorm/builder

WARNNING: Currently, only query conditions are supported. Below is the supported conditions.

1. Eq is a redefine of a map, you can give one or more conditions to Eq

import . "github.com/coscms/xorm/builder"

sql, args, _ := ToSQL(Eq{"a":1})
// a=? [1]
sql, args, _ := ToSQL(Eq{"b":"c"}.And(Eq{"c": 0}))
// b=? AND c=? ["c", 0]
sql, args, _ := ToSQL(Eq{"b":"c", "c":0})
// b=? AND c=? ["c", 0]
sql, args, _ := ToSQL(Eq{"b":"c"}.Or(Eq{"b":"d"}))
// b=? OR b=? ["c", "d"]
sql, args, _ := ToSQL(Eq{"b": []string{"c", "d"}})
// b IN (?,?) ["c", "d"]
sql, args, _ := ToSQL(Eq{"b": 1, "c":[]int{2, 3}})
// b=? AND c IN (?,?) [1, 2, 3]

2. Neq is the same to Eq

import . "github.com/coscms/xorm/builder"

sql, args, _ := ToSQL(Neq{"a":1})
// a<>? [1]
sql, args, _ := ToSQL(Neq{"b":"c"}.And(Neq{"c": 0}))
// b<>? AND c<>? ["c", 0]
sql, args, _ := ToSQL(Neq{"b":"c", "c":0})
// b<>? AND c<>? ["c", 0]
sql, args, _ := ToSQL(Neq{"b":"c"}.Or(Neq{"b":"d"}))
// b<>? OR b<>? ["c", "d"]
sql, args, _ := ToSQL(Neq{"b": []string{"c", "d"}})
// b NOT IN (?,?) ["c", "d"]
sql, args, _ := ToSQL(Neq{"b": 1, "c":[]int{2, 3}})
// b<>? AND c NOT IN (?,?) [1, 2, 3]

3. Gt, Gte, Lt, Lte

import . "github.com/coscms/xorm/builder"

sql, args, _ := ToSQL(Gt{"a", 1}.And(Gte{"b", 2}))
// a>? AND b>=? [1, 2]
sql, args, _ := ToSQL(Lt{"a", 1}.Or(Lte{"b", 2}))
// a<? OR b<=? [1, 2]

4. Like

import . "github.com/coscms/xorm/builder"

sql, args, _ := ToSQL(Like{"a", "c"})
// a LIKE ? [%c%]

5. Expr you can customerize your sql with Expr

import . "github.com/coscms/xorm/builder"

sql, args, _ := ToSQL(Expr("a = ? ", 1))
// a = ? [1]
sql, args, _ := ToSQL(Eq{"a": Expr("select id from table where c = ?", 1)})
// a=(select id from table where c = ?) [1]

6. In and NotIn

import . "github.com/coscms/xorm/builder"

sql, args, _ := ToSQL(In("a", 1, 2, 3))
// a IN (?,?,?) [1,2,3]
sql, args, _ := ToSQL(In("a", []int{1, 2, 3}))
// a IN (?,?,?) [1,2,3]
sql, args, _ := ToSQL(In("a", Expr("select id from b where c = ?", 1))))
// a IN (select id from b where c = ?) [1]

7. IsNull and NotNull

import . "github.com/coscms/xorm/builder"

sql, args, _ := ToSQL(IsNull{"a"})
// a IS NULL []
sql, args, _ := ToSQL(NotNull{"b"})
 // b IS NOT NULL []

8. And(conds ...Cond), And can connect one or more condtions via AND

import . "github.com/coscms/xorm/builder"

sql, args, _ := ToSQL(And(Eq{"a":1}, Like{"b", "c"}, Neq{"d", 2}))
// a=? AND b LIKE ? AND d<>? [1, %c%, 2]

9. Or(conds ...Cond), Or can connect one or more conditions via Or

import . "github.com/coscms/xorm/builder"

sql, args, _ := ToSQL(Or(Eq{"a":1}, Like{"b", "c"}, Neq{"d", 2}))
// a=? OR b LIKE ? OR d<>? [1, %c%, 2]
sql, args, _ := ToSQL(Or(Eq{"a":1}, And(Like{"b", "c"}, Neq{"d", 2})))
// a=? OR (b LIKE ? AND d<>?) [1, %c%, 2]

10. Between

import . "github.com/coscms/xorm/builder"

sql, args, _ := ToSQL(Between("a", 1, 2))
// a BETWEEN 1 AND 2

11. define yourself conditions Since Cond is a interface, you can define yourself conditions and compare with them

Index

Constants

This section is empty.

Variables

View Source
var (
	// ErrNotSupportType not supported SQL type error
	ErrNotSupportType = errors.New("not supported SQL type")
	// ErrNoNotInConditions no NOT IN params error
	ErrNoNotInConditions = errors.New("No NOT IN conditions")
	// ErrNoInConditions no IN params error
	ErrNoInConditions = errors.New("No IN conditions")
)

Functions

func ToSQL

func ToSQL(cond interface{}, keyFilters ...func(string) string) (string, []interface{}, error)

ToSQL convert a builder or condtions to SQL and args

func WriteMap

func WriteMap(w Writer, data map[string]interface{}, op string) error

WriteMap writes conditions' SQL to Writer, op could be =, <>, >, <, <=, >= and etc.

Types

type Between

type Between struct {
	Col     string
	LessVal interface{}
	MoreVal interface{}
}

Between implmentes between condition

func (Between) And

func (between Between) And(conds ...Cond) Cond

And implments And with other conditions

func (Between) IsValid

func (between Between) IsValid() bool

IsValid tests if the condition is valid

func (Between) Or

func (between Between) Or(conds ...Cond) Cond

Or implments Or with other conditions

func (Between) WriteTo

func (between Between) WriteTo(w Writer) error

WriteTo write data to Writer

type Builder

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

Builder describes a SQL statement

func Delete

func Delete(conds ...Cond) *Builder

Delete creates a delete Builder

func Insert

func Insert(eq Eq) *Builder

Insert creates an insert Builder

func Select

func Select(cols ...string) *Builder

Select creates a select Builder

func Update

func Update(updates ...Eq) *Builder

Update creates an update Builder

func (*Builder) And

func (b *Builder) And(cond Cond) *Builder

And sets AND condition

func (*Builder) CrossJoin

func (b *Builder) CrossJoin(joinTable string, joinCond interface{}) *Builder

CrossJoin sets cross join SQL

func (*Builder) Delete

func (b *Builder) Delete(conds ...Cond) *Builder

Delete sets delete SQL

func (*Builder) From

func (b *Builder) From(tableName string) *Builder

From sets the table name

func (*Builder) FullJoin

func (b *Builder) FullJoin(joinTable string, joinCond interface{}) *Builder

FullJoin sets full join SQL

func (*Builder) InnerJoin

func (b *Builder) InnerJoin(joinTable string, joinCond interface{}) *Builder

InnerJoin sets inner join

func (*Builder) Insert

func (b *Builder) Insert(eq Eq) *Builder

Insert sets insert SQL

func (*Builder) Into

func (b *Builder) Into(tableName string) *Builder

Into sets insert table name

func (*Builder) Join

func (b *Builder) Join(joinType, joinTable string, joinCond interface{}) *Builder

Join sets join table and contions

func (*Builder) LeftJoin

func (b *Builder) LeftJoin(joinTable string, joinCond interface{}) *Builder

LeftJoin sets left join SQL

func (*Builder) Or

func (b *Builder) Or(cond Cond) *Builder

Or sets OR condition

func (*Builder) RightJoin

func (b *Builder) RightJoin(joinTable string, joinCond interface{}) *Builder

RightJoin sets right join SQL

func (*Builder) Select

func (b *Builder) Select(cols ...string) *Builder

Select sets select SQL

func (*Builder) ToSQL

func (b *Builder) ToSQL(keyFilters ...func(string) string) (string, []interface{}, error)

ToSQL convert a builder to SQL and args

func (*Builder) Update

func (b *Builder) Update(updates ...Eq) *Builder

Update sets update SQL

func (*Builder) Where

func (b *Builder) Where(cond Cond) *Builder

Where sets where SQL

func (*Builder) WriteTo

func (b *Builder) WriteTo(w Writer) error

WriteTo implements Writer interface

type BytesWriter

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

BytesWriter implments Writer and save SQL in bytes.Buffer

func NewWriter

func NewWriter() *BytesWriter

NewWriter creates a new string writer

func (*BytesWriter) Append

func (s *BytesWriter) Append(args ...interface{})

Append appends args to Writer

func (*BytesWriter) Args

func (s *BytesWriter) Args() []interface{}

func (*BytesWriter) Bytes

func (s *BytesWriter) Bytes() []byte

func (*BytesWriter) Key

func (s *BytesWriter) Key(key string) string

func (*BytesWriter) String

func (s *BytesWriter) String() string

func (*BytesWriter) Write

func (s *BytesWriter) Write(buf []byte) (int, error)

Write writes data to Writer

type Cond

type Cond interface {
	WriteTo(Writer) error
	And(...Cond) Cond
	Or(...Cond) Cond
	IsValid() bool
}

Cond defines an interface

func And

func And(conds ...Cond) Cond

And generates AND conditions

func Expr

func Expr(sql string, args ...interface{}) Cond

Expr generate customerize SQL

func In

func In(col string, values ...interface{}) Cond

In generates IN condition

func NewCond

func NewCond() Cond

NewCond creates an empty condition

func NotIn

func NotIn(col string, values ...interface{}) Cond

NotIn generate NOT IN condition

func Or

func Or(conds ...Cond) Cond

Or sets OR conditions

type Decr

type Decr int

Decr implements a type used by Eq

type Eq

type Eq map[string]interface{}

Eq defines equals conditions

func (Eq) And

func (eq Eq) And(conds ...Cond) Cond

And implements And with other conditions

func (Eq) IsValid

func (eq Eq) IsValid() bool

IsValid tests if this Eq is valid

func (Eq) Or

func (eq Eq) Or(conds ...Cond) Cond

Or implements Or with other conditions

func (Eq) WriteTo

func (eq Eq) WriteTo(w Writer) error

WriteTo writes SQL to Writer

type Ge

type Ge map[string]interface{}

Ge defines >= condition

func (Ge) And

func (ge Ge) And(conds ...Cond) Cond

And implements And with other conditions

func (Ge) IsValid

func (ge Ge) IsValid() bool

IsValid tests if this Eq is valid

func (Ge) Or

func (ge Ge) Or(conds ...Cond) Cond

Or implements Or with other conditions

func (Ge) WriteTo

func (ge Ge) WriteTo(w Writer) error

WriteTo write SQL to Writer

type Gt

type Gt map[string]interface{}

Gt defines > condition

func (Gt) And

func (gt Gt) And(conds ...Cond) Cond

And implements And with other conditions

func (Gt) IsValid

func (gt Gt) IsValid() bool

IsValid tests if this Eq is valid

func (Gt) Or

func (gt Gt) Or(conds ...Cond) Cond

Or implements Or with other conditions

func (Gt) WriteTo

func (gt Gt) WriteTo(w Writer) error

WriteTo write SQL to Writer

type Gte

type Gte map[string]interface{}

Gte defines >= condition

func (Gte) And

func (gte Gte) And(conds ...Cond) Cond

And implements And with other conditions

func (Gte) IsValid

func (gte Gte) IsValid() bool

IsValid tests if this Eq is valid

func (Gte) Or

func (gte Gte) Or(conds ...Cond) Cond

Or implements Or with other conditions

func (Gte) WriteTo

func (gte Gte) WriteTo(w Writer) error

WriteTo write SQL to Writer

type Incr

type Incr int

Incr implements a type used by Eq

type IsNull

type IsNull [1]string

IsNull defines IS NULL condition

func (IsNull) And

func (isNull IsNull) And(conds ...Cond) Cond

And implements And with other conditions

func (IsNull) IsValid

func (isNull IsNull) IsValid() bool

IsValid tests if this condition is valid

func (IsNull) Or

func (isNull IsNull) Or(conds ...Cond) Cond

Or implements Or with other conditions

func (IsNull) WriteTo

func (isNull IsNull) WriteTo(w Writer) error

WriteTo write SQL to Writer

type Le

type Le Lte

Le defines <= condition

func (Le) And

func (le Le) And(conds ...Cond) Cond

And implements And with other conditions

func (Le) IsValid

func (le Le) IsValid() bool

IsValid tests if this Eq is valid

func (Le) Or

func (le Le) Or(conds ...Cond) Cond

Or implements Or with other conditions

func (Le) WriteTo

func (le Le) WriteTo(w Writer) error

WriteTo write SQL to Writer

type Like

type Like [2]string

Like defines like condition

func (Like) And

func (like Like) And(conds ...Cond) Cond

And implements And with other conditions

func (Like) IsValid

func (like Like) IsValid() bool

IsValid tests if this condition is valid

func (Like) Or

func (like Like) Or(conds ...Cond) Cond

Or implements Or with other conditions

func (Like) WriteTo

func (like Like) WriteTo(w Writer) error

WriteTo write SQL to Writer

type Lt

type Lt map[string]interface{}

Lt defines < condition

func (Lt) And

func (lt Lt) And(conds ...Cond) Cond

And implements And with other conditions

func (Lt) IsValid

func (lt Lt) IsValid() bool

IsValid tests if this Eq is valid

func (Lt) Or

func (lt Lt) Or(conds ...Cond) Cond

Or implements Or with other conditions

func (Lt) WriteTo

func (lt Lt) WriteTo(w Writer) error

WriteTo write SQL to Writer

type Lte

type Lte map[string]interface{}

Lte defines <= condition

func (Lte) And

func (lte Lte) And(conds ...Cond) Cond

And implements And with other conditions

func (Lte) IsValid

func (lte Lte) IsValid() bool

IsValid tests if this Eq is valid

func (Lte) Or

func (lte Lte) Or(conds ...Cond) Cond

Or implements Or with other conditions

func (Lte) WriteTo

func (lte Lte) WriteTo(w Writer) error

WriteTo write SQL to Writer

type Ne

type Ne map[string]interface{}

Ne defines not equal conditions

func (Ne) And

func (ne Ne) And(conds ...Cond) Cond

And implements And with other conditions

func (Ne) IsValid

func (ne Ne) IsValid() bool

IsValid tests if this condition is valid

func (Ne) Or

func (ne Ne) Or(conds ...Cond) Cond

Or implements Or with other conditions

func (Ne) WriteTo

func (ne Ne) WriteTo(w Writer) error

WriteTo writes SQL to Writer

type Neq

type Neq map[string]interface{}

Neq defines not equal conditions

func (Neq) And

func (neq Neq) And(conds ...Cond) Cond

And implements And with other conditions

func (Neq) IsValid

func (neq Neq) IsValid() bool

IsValid tests if this condition is valid

func (Neq) Or

func (neq Neq) Or(conds ...Cond) Cond

Or implements Or with other conditions

func (Neq) WriteTo

func (neq Neq) WriteTo(w Writer) error

WriteTo writes SQL to Writer

type Not

type Not [1]Cond

Not defines NOT condition

func (Not) And

func (not Not) And(conds ...Cond) Cond

And implements And with other conditions

func (Not) IsValid

func (not Not) IsValid() bool

IsValid tests if this condition is valid

func (Not) Or

func (not Not) Or(conds ...Cond) Cond

Or implements Or with other conditions

func (Not) WriteTo

func (not Not) WriteTo(w Writer) error

WriteTo writes SQL to Writer

type NotNull

type NotNull [1]string

NotNull defines NOT NULL condition

func (NotNull) And

func (notNull NotNull) And(conds ...Cond) Cond

And implements And with other conditions

func (NotNull) IsValid

func (notNull NotNull) IsValid() bool

IsValid tests if this condition is valid

func (NotNull) Or

func (notNull NotNull) Or(conds ...Cond) Cond

Or implements Or with other conditions

func (NotNull) WriteTo

func (notNull NotNull) WriteTo(w Writer) error

WriteTo write SQL to Writer

type Writer

type Writer interface {
	io.Writer
	Append(...interface{})
	Key(string) string
}

Writer defines the interface

Jump to

Keyboard shortcuts

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