builder

package module
v0.3.9 Latest Latest
Warning

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

 Go to latest Published: Feb 4, 2021 License: BSD-3-Clause Imports: 9 Imported by: 241

README

SQL builder

Build Status

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

Make sure you have installed Go 1.8+ and then:

go get xorm.io/builder

Insert

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

// INSERT INTO table1 SELECT * FROM table2
sql, err := builder.Insert().Into("table1").Select().From("table2").ToBoundSQL()

// INSERT INTO table1 (a, b) SELECT b, c FROM table2
sql, err = builder.Insert("a, b").Into("table1").Select("b, c").From("table2").ToBoundSQL()

Select

// Simple Query
sql, args, err := Select("c, d").From("table1").Where(Eq{"a": 1}).ToSQL()
// With join
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()
// From sub query
sql, args, err := Select("sub.id").From(Select("c").From("table1").Where(Eq{"a": 1}), "sub").Where(Eq{"b": 1}).ToSQL()
// From union query
sql, args, err = Select("sub.id").From(
	Select("id").From("table1").Where(Eq{"a": 1}).Union("all", Select("id").From("table1").Where(Eq{"a": 2})),"sub").
	Where(Eq{"b": 1}).ToSQL()
// With order by
sql, args, err = Select("a", "b", "c").From("table1").Where(Eq{"f1": "v1", "f2": "v2"}).
		OrderBy("a ASC").ToSQL()
// With limit.
// Be careful! You should set up specific dialect for builder before performing a query with LIMIT
sql, args, err = Dialect(MYSQL).Select("a", "b", "c").From("table1").OrderBy("a ASC").
		Limit(5, 10).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()

Union

sql, args, err := Select("*").From("a").Where(Eq{"status": "1"}).
		Union("all", Select("*").From("a").Where(Eq{"status": "2"})).
		Union("distinct", Select("*").From("a").Where(Eq{"status": "3"})).
		Union("", Select("*").From("a").Where(Eq{"status": "4"})).
		ToSQL()

Conditions

  • Eq is a redefine of a map, you can give one or more conditions to Eq
import . "xorm.io/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 . "xorm.io/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 . "xorm.io/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 . "xorm.io/builder"

sql, args, _ := ToSQL(Like{"a", "c"})
// a LIKE ? [%c%]
  • Expr you can customerize your sql with Expr
import . "xorm.io/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 . "xorm.io/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 . "xorm.io/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 . "xorm.io/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 . "xorm.io/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 . "xorm.io/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 xorm.io/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 . "xorm.io/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 . "xorm.io/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 . "xorm.io/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 . "xorm.io/builder"

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

5. Expr you can customerize your sql with Expr 

import . "xorm.io/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 . "xorm.io/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 . "xorm.io/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 . "xorm.io/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 . "xorm.io/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 . "xorm.io/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

View Source 
const (
	POSTGRES = "postgres"
	SQLITE   = "sqlite3"
	MYSQL    = "mysql"
	MSSQL    = "mssql"
	ORACLE   = "oracle"

	UNION     = "union"
	INTERSECT = "intersect"
	EXCEPT    = "except"
)

all databasees

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")
	// ErrNeedMoreArguments need more arguments
	ErrNeedMoreArguments = errors.New("Need more sql arguments")
	// ErrNoTableName no table name
	ErrNoTableName = errors.New("No table indicated")
	// ErrNoColumnToUpdate no column to update
	ErrNoColumnToUpdate = errors.New("No column(s) to update")
	// ErrNoColumnToInsert no column to insert
	ErrNoColumnToInsert = errors.New("No column(s) to insert")
	// ErrNotSupportDialectType not supported dialect type error
	ErrNotSupportDialectType = errors.New("Not supported dialect type")
	// ErrNotUnexpectedUnionConditions using union in a wrong way
	ErrNotUnexpectedUnionConditions = errors.New("Unexpected conditional fields in UNION query")
	// ErrUnsupportedUnionMembers unexpected members in UNION query
	ErrUnsupportedUnionMembers = errors.New("Unexpected members in UNION query")
	// ErrUnexpectedSubQuery Unexpected sub-query in SELECT query
	ErrUnexpectedSubQuery = errors.New("Unexpected sub-query in SELECT query")
	// ErrDialectNotSetUp dialect is not setup yet
	ErrDialectNotSetUp = errors.New("Dialect is not setup yet, try to use `Dialect(dbType)` at first")
	// ErrInvalidLimitation offset or limit is not correct
	ErrInvalidLimitation = errors.New("Offset or limit is not correct")
	// ErrUnnamedDerivedTable Every derived table must have its own alias
	ErrUnnamedDerivedTable = errors.New("Every derived table must have its own alias")
	// ErrInconsistentDialect Inconsistent dialect in same builder
	ErrInconsistentDialect = errors.New("Inconsistent dialect in same builder")
)

Functions

func ConvertPlaceholder 

func ConvertPlaceholder(sql, prefix string) (string, error)

ConvertPlaceholder replaces the place holder ? to $1, $2 ... or :1, :2 ... according prefix

func ConvertToBoundSQL 

func ConvertToBoundSQL(sql string, args []interface{}) (string, error)

ConvertToBoundSQL will convert SQL and args to a bound SQL

func ToBoundSQL 

func ToBoundSQL(cond interface{}) (string, error)

ToBoundSQL convert a builder or conditions to parameters bound SQL

func ToSQL 

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

ToSQL convert a builder or conditions 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 Dialect 

func Dialect(dialect string) *Builder

Dialect sets the db dialect of Builder.

func Insert 

func Insert(eq ...interface{}) *Builder

Insert creates an insert Builder

func MsSQL 

func MsSQL() *Builder

MsSQL is shortcut of Dialect(MsSQL)

func MySQL 

func MySQL() *Builder

MySQL is shortcut of Dialect(MySQL)

func Oracle 

func Oracle() *Builder

Oracle is shortcut of Dialect(Oracle)

func Postgres 

func Postgres() *Builder

Postgres is shortcut of Dialect(Postgres)

func SQLite 

func SQLite() *Builder

SQLite is shortcut of Dialect(SQLITE)

func Select 

func Select(cols ...string) *Builder

Select creates a select Builder

func Update 

func Update(updates ...Cond) *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, joinCond interface{}) *Builder

CrossJoin sets cross join SQL

func (*Builder) Delete 

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

Delete sets delete SQL

func (*Builder) Except added in v0.3.7 

func (b *Builder) Except(distinctType string, cond *Builder) *Builder

Except sets except conditions

func (*Builder) From 

func (b *Builder) From(subject interface{}, alias ...string) *Builder

From sets from subject(can be a table name in string or a builder pointer) and its alias

func (*Builder) FullJoin 

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

FullJoin sets full join SQL

func (*Builder) GroupBy 

func (b *Builder) GroupBy(groupby string) *Builder

GroupBy groupby SQL

func (*Builder) Having 

func (b *Builder) Having(having string) *Builder

Having having SQL

func (*Builder) InnerJoin 

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

InnerJoin sets inner join

func (*Builder) Insert 

func (b *Builder) Insert(eq ...interface{}) *Builder

Insert sets insert SQL

func (*Builder) Intersect added in v0.3.7 

func (b *Builder) Intersect(distinctType string, cond *Builder) *Builder

Intersect sets intersect conditions

func (*Builder) Into 

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

Into sets insert table name

func (*Builder) Join 

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

Join sets join table and conditions

func (*Builder) LeftJoin 

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

LeftJoin sets left join SQL

func (*Builder) Limit 

func (b *Builder) Limit(limitN int, offset ...int) *Builder

Limit sets limitN condition

func (*Builder) Or 

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

Or sets OR condition

func (*Builder) OrderBy 

func (b *Builder) OrderBy(orderBy string) *Builder

OrderBy orderBy SQL

func (*Builder) RightJoin 

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

RightJoin sets right join SQL

func (*Builder) Select 

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

Select sets select SQL

func (*Builder) TableName 

func (b *Builder) TableName() string

TableName returns the table name

func (*Builder) ToBoundSQL 

func (b *Builder) ToBoundSQL() (string, error)

ToBoundSQL generated a bound SQL string

func (*Builder) ToSQL 

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

ToSQL convert a builder to SQL and args

func (*Builder) Union 

func (b *Builder) Union(distinctType string, cond *Builder) *Builder

Union sets union conditions

func (*Builder) Update 

func (b *Builder) Update(updates ...Cond) *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 {
	*strings.Builder
	// 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 (w *BytesWriter) Append(args ...interface{})

Append appends args to Writer

func (*BytesWriter) Args added in v0.3.6 

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

Args returns args

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 If 

func If(condition bool, condTrue Cond, condFalse ...Cond) Cond

If returns Cond via condition

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) OpWriteTo added in v0.3.6 

func (eq Eq) OpWriteTo(op string, w Writer) error

OpWriteTo writes conditions with special operator

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 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 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 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 UpdateCond added in v0.3.6 

type UpdateCond interface {
	IsValid() bool
	OpWriteTo(op string, w Writer) error
}

UpdateCond defines an interface that cond could be used with update

type Writer 

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

Writer defines the interface

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.