querybuilder

package
v0.0.0-...-a3546ac Latest Latest
Warning

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

 Go to latest Published: Nov 22, 2021 License: MIT Imports: 7 Imported by: 2

README

querybuilder SQL 语句拼接器

提供拼接 sql 语句的接口，支持设置 sql 类型生成不同的语句

使用方法

使用 QueryBuilder 需要创建 builder 或者使用实现 Table 接口的对象 注意，第一次使用 builder 创建语句后，就无法再修改驱动类型。

直接创建
//创建builder
builder:=querybuilder.New()
builder.Driver="mysql"
使用 Table 对象

Table 对象是使用实现了 DBTable 接口的对象操作实现的操作类。 github.com/herb-go/datasource/sql/db 的 Table 对象是一个标准的可用于创建 Table 的对象

//使用 Table 对象
table:=NewTable(dbtable)
builder:=table.QueryBuilder()
执行语句
builder创建的语句可以通过Exec ,QueryRow ,QueryRows 三个方法及其衍生方式执行。

执行时需要传入一个实现了DB接口的对象

github.com/herb-go/datasource/sql/db 的DB,Table,TxDB都是有效的DB对象
Table对象也通过继承实现了DB对象的接口

//通过builder来执行
sqlResult,err:=builder.Exec(db,query)
sqlRow:=builder.QueryRow(db,query)
sqlRows,err:=builder.QueryRows(db,query)

//通过查询语句来执行
sqlResult,err:=query.Exec(db)
sqlRow:=query.QueryRow(db)
sqlRows,err:=query.QueryRows(db)

支持的语句

Field 数据字段

Field 与 Fields 对象是为了方便进行数据库数据与程序数据结构进行映射儿创建的对象

SELECT 语句

用户查询语句。使用方式:

selectquery:=builder.NewSelect()
selectquery.Select.AddFields(fields)
selectquery.OrderBy.Add("id", false)
selectquery.Limit.SetLimit(1)
selectquery.Limit.SetOffset(1)
selectquery.Join.LeftJoin().On(builder.New("field1=field2")).Alias("t2", "table2")
row := selectquery.QueryRow(table1)
err := selectquery.Result().BindFields(fields).ScanFrom(row)
SELECT 子语句
FROM 子语句
JOIN 子语句
WHERE 子语句
GROUPBY 子语句
ORDERBY 子语句
OTHER 额外部分子语句
INSERT 语句
UPDATE 语句
DELETE 语句
MISC 杂项

支持的数据库及类型

mysql

驱动:github.com/go-sql-driver/mysql

sqlite

驱动:github.com/mattn/go-sqlite3

posgresql

驱动:github.com/lib/pq

mssql

驱动:github.com/denisenkom/go-mssqldb

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var Debug = false

Debug querybuild debug mode. If enabled,all sql commands and args will bt sent to logger

View Source 
var DefaultDriver = &EmptyBuilderDriver{}

DefaultDriver default driver

View Source 
var DefaultLogger = func(timestamp int64, cmd string, args []interface{}) {
	spent := time.Duration((time.Now().UnixNano() - timestamp)) * time.Nanosecond
	fmt.Println(time.Now().Format("2006-01-02 15:04:05") + " SQL query debug:")
	fmt.Println("Query:")
	lines := strings.Split(cmd, "\n")
	for k := range lines {
		fmt.Println("\t" + lines[k])
	}
	fmt.Println("Args:")
	argsString := make([]string, len(args))
	for k := range args {
		argsString[k] = fmt.Sprint(args[k])
	}
	fmt.Println("\t[" + strings.Join(argsString, " , ") + "]")
	stacks := string(debug.Stack())
	stacklines := strings.Split(stacks, "\n")
	if len(stacklines) > 9 {
		fmt.Println("Stack:")
		fmt.Println("\t" + stacklines[7])
		fmt.Println("\t" + stacklines[8])
	}
	fmt.Println("Time spent:")
	for _, v := range timeDurationList {
		if spent > 10*v.Duration {
			fmt.Printf("\t%d %s \n", spent/v.Duration, v.Label)
			break
		}
	}
	fmt.Println()
}

DefaultLogger default logger which print qurey command.args and spent time to std.output

View Source 
var Logger func(timestamp int64, cmd string, args []interface{})

Logger query logger

Functions

func RegisterDriver 

func RegisterDriver(name string, driver BuilderDriver)

RegisterDriver register querybuilder driver with given name.

Types

type Builder 

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

Builder query builder struct

func New 

func New() *Builder

New create new query builder

func (*Builder) And 

func (b *Builder) And(q ...Query) *PlainQuery

And concat queries with AND operation.

func (*Builder) Between 

func (b *Builder) Between(field string, start interface{}, end interface{}) *PlainQuery

Between return field between start and end query

func (*Builder) Comma 

func (b *Builder) Comma(q ...Query) *PlainQuery

Comma concat queries with Comma.

func (*Builder) Concat 

func (b *Builder) Concat(q ...Query) *PlainQuery

Concat concat queries with space.

func (*Builder) CountField 

func (b *Builder) CountField() string

CountField return select count field

func (*Builder) Equal 

func (b *Builder) Equal(field string, arg interface{}) *PlainQuery

Equal return field equal to value query

func (*Builder) EscapeSearch 

func (b *Builder) EscapeSearch(arg string) string

EscapeSearch escape search arg

func (*Builder) Exec 

func (b *Builder) Exec(db DB, q Query) (sql.Result, error)

Exec exec query in given db. return sql result and error query will be convert by builder driver.

func (*Builder) In 

func (b *Builder) In(field string, args interface{}) *PlainQuery

In return field in args query

func (*Builder) IsDuplicate 

func (b *Builder) IsDuplicate(err error) bool

IsDuplicate check if error is Is duplicate error.

func (*Builder) IsNotNull 

func (b *Builder) IsNotNull(field string) *PlainQuery

IsNotNull return field is not null query

func (*Builder) IsNull 

func (b *Builder) IsNull(field string) *PlainQuery

IsNull return field is null query

func (*Builder) Lines 

func (b *Builder) Lines(q ...Query) *PlainQuery

Lines concat queries with New line.

func (*Builder) LoadDriver 

func (b *Builder) LoadDriver() BuilderDriver

LoadDriver load builder driver by Driver field Only load one time.

func (*Builder) New 

func (b *Builder) New(command string, args ...interface{}) *PlainQuery

New create new plain query with given command and args

func (*Builder) NewDeleteClause 

func (b *Builder) NewDeleteClause(tableName string) *DeleteClause

NewDeleteClause create new delete clause with given table name.

func (*Builder) NewDeleteQuery 

func (b *Builder) NewDeleteQuery(TableName string) *DeleteQuery

NewDeleteQuery create new delete query with given table name.s

func (*Builder) NewFromClause 

func (b *Builder) NewFromClause() *FromClause

NewFromClause create new form clause

func (*Builder) NewGroupByClause 

func (b *Builder) NewGroupByClause() *GroupByClause

NewGroupByClause create new group by clause.

func (*Builder) NewHavingClause 

func (b *Builder) NewHavingClause() *HavingClause

NewHavingClause create new having clause

func (*Builder) NewInsertClause 

func (b *Builder) NewInsertClause(tableName string) *InsertClause

NewInsertClause create new insert clause with given table name

func (*Builder) NewInsertQuery 

func (b *Builder) NewInsertQuery(tableName string) *InsertQuery

NewInsertQuery create new insert query.

func (*Builder) NewJoinClause 

func (b *Builder) NewJoinClause() *JoinClause

NewJoinClause create new join clause

func (*Builder) NewLimitClause 

func (b *Builder) NewLimitClause() *LimitClause

NewLimitClause create new limit clause

func (*Builder) NewOrderByClause 

func (b *Builder) NewOrderByClause() *OrderByClause

NewOrderByClause create order by clause

func (*Builder) NewSelectClause 

func (b *Builder) NewSelectClause() *SelectClause

NewSelectClause create new select clause

func (*Builder) NewSelectQuery 

func (b *Builder) NewSelectQuery() *SelectQuery

NewSelectQuery create new select

func (*Builder) NewUpdateClause 

func (b *Builder) NewUpdateClause(tableName string) *UpdateClause

NewUpdateClause create new update clause with given table name.

func (*Builder) NewUpdateQuery 

func (b *Builder) NewUpdateQuery(tableName string) *UpdateQuery

NewUpdateQuery create new update query with given table name.

func (*Builder) NewValueList 

func (b *Builder) NewValueList(data ...interface{}) *PlainQuery

NewValueList create new value list with given data.

func (*Builder) NewWhereClause 

func (b *Builder) NewWhereClause() *WhereClause

NewWhereClause create new where clause

func (*Builder) Or 

func (b *Builder) Or(q ...Query) *PlainQuery

Or concat queries with Or operation.

func (*Builder) QueryRow 

func (b *Builder) QueryRow(db DB, q Query) *sql.Row

QueryRow query rowsfrom db with given query. query will be convert by builder driver.

func (*Builder) QueryRows 

func (b *Builder) QueryRows(db DB, q Query) (*sql.Rows, error)

QueryRows query rows from db with given query. query will be convert by builder driver.

func (*Builder) Search 

func (b *Builder) Search(field string, arg string) *PlainQuery

Search return search field query. 

arg will be ecapced with EscapeSearch

func (*Builder) TruncateTableQuery 

func (b *Builder) TruncateTableQuery(table string) *PlainQuery

TruncateTableQuery return truncate table query

type BuilderDriver 

type BuilderDriver interface {
	ConvertQuery(q Query) (string, []interface{})
	TruncateTableCommandBuilder(t string) string
	LimitCommandBuilder(q *LimitClause) string
	LimitArgBuilder(q *LimitClause) []interface{}
	DeleteCommandBuilder(q *DeleteClause) string
	DeleteArgBuilder(q *DeleteClause) []interface{}
	CountField() string
	IsDuplicate(error) bool
}

BuilderDriver query builder driver interface

type DB 

type DB interface {
	Exec(query string, args ...interface{}) (sql.Result, error)
	Query(query string, args ...interface{}) (*sql.Rows, error)
	QueryRow(query string, args ...interface{}) *sql.Row
}

DB sql database interface.

type DeleteClause 

type DeleteClause struct {
	// Builder query builder which create this query.
	Builder *Builder
	//TableName database table name
	TableName string
	// Prefix  query which insert between"DELETE" command and  table name.
	Prefix *PlainQuery
}

DeleteClause delete clause struct

func (*DeleteClause) QueryArgs 

func (q *DeleteClause) QueryArgs() []interface{}

QueryArgs return query adts

func (*DeleteClause) QueryCommand 

func (q *DeleteClause) QueryCommand() string

QueryCommand return query command

type DeleteQuery 

type DeleteQuery struct {
	// Builder query builder which create this query.
	Builder *Builder
	// Delete delete query
	Delete *DeleteClause
	// Where where query
	Where *WhereClause
	// Other  query after where
	Other *PlainQuery
}

DeleteQuery delete query

func (*DeleteQuery) Query 

func (d *DeleteQuery) Query() *PlainQuery

Query return plain query

type EmptyBuilderDriver 

type EmptyBuilderDriver struct {
}

EmptyBuilderDriver empty query builder. Using mysql statements

func (EmptyBuilderDriver) ConvertQuery 

func (d EmptyBuilderDriver) ConvertQuery(q Query) (string, []interface{})

ConvertQuery convert query to command and args

func (*EmptyBuilderDriver) CountField 

func (d *EmptyBuilderDriver) CountField() string

CountField return count field

func (*EmptyBuilderDriver) DeleteArgBuilder 

func (d *EmptyBuilderDriver) DeleteArgBuilder(q *DeleteClause) []interface{}

DeleteArgBuilder build delete args with given delete clause.

func (*EmptyBuilderDriver) DeleteCommandBuilder 

func (d *EmptyBuilderDriver) DeleteCommandBuilder(q *DeleteClause) string

DeleteCommandBuilder build delete command with given delete clause.

func (*EmptyBuilderDriver) IsDuplicate 

func (d *EmptyBuilderDriver) IsDuplicate(err error) bool

IsDuplicate check if error is Is duplicate error.

func (*EmptyBuilderDriver) LimitArgBuilder 

func (d *EmptyBuilderDriver) LimitArgBuilder(q *LimitClause) []interface{}

LimitArgBuilder build limit args with given limit clause.

func (*EmptyBuilderDriver) LimitCommandBuilder 

func (d *EmptyBuilderDriver) LimitCommandBuilder(q *LimitClause) string

LimitCommandBuilder build limit command with given limit query.

func (EmptyBuilderDriver) TruncateTableCommandBuilder 

func (d EmptyBuilderDriver) TruncateTableCommandBuilder(t string) string

TruncateTableCommandBuilder return truncate table query.

type Field 

type Field struct {
	// Field field name
	Field string
	// Data field data
	Data interface{}
}

Field query field struct

func NewField 

func NewField() *Field

NewField Create new field

type Fields 

type Fields []*Field

Fields field list

func NewFields 

func NewFields() *Fields

NewFields create new fields

func (*Fields) Set 

func (f *Fields) Set(field string, data interface{}) *Fields

Set set field value wth given field name dana. return fields self.

type FromClause 

type FromClause struct {
	Buidler *Builder
	Tables  [][2]string
}

FromClause from caluse struuct

func (*FromClause) Add 

func (q *FromClause) Add(tableName string) *FromClause

Add add table to form clause

func (*FromClause) AddAlias 

func (q *FromClause) AddAlias(alias string, tableName string) *FromClause

AddAlias add table to from clause with given table name and alias

func (*FromClause) QueryArgs 

func (q *FromClause) QueryArgs() []interface{}

QueryArgs return query args.

func (*FromClause) QueryCommand 

func (q *FromClause) QueryCommand() string

QueryCommand return query command.

type GroupByClause 

type GroupByClause struct {
	Buidler *Builder
	Fields  []string
}

GroupByClause group by clause struct

func (*GroupByClause) Add 

func (q *GroupByClause) Add(fields ...string) *GroupByClause

Add add fields to group by clause

func (*GroupByClause) QueryArgs 

func (q *GroupByClause) QueryArgs() []interface{}

QueryArgs return query args.

func (*GroupByClause) QueryCommand 

func (q *GroupByClause) QueryCommand() string

QueryCommand return query command

type HavingClause 

type HavingClause struct {
	Buidler   *Builder
	Condition *PlainQuery
}

HavingClause having clause struct

func (*HavingClause) QueryArgs 

func (q *HavingClause) QueryArgs() []interface{}

QueryArgs return query args

func (*HavingClause) QueryCommand 

func (q *HavingClause) QueryCommand() string

QueryCommand return query command

type InsertClause 

type InsertClause struct {
	Builder   *Builder
	Prefix    *PlainQuery
	TableName string
	Data      []QueryData
	Select    *SelectQuery
}

InsertClause insert clause

func (*InsertClause) Add 

func (q *InsertClause) Add(field string, data interface{}) *InsertClause

Add add field to insert clause with given field name and data

func (*InsertClause) AddFields 

func (q *InsertClause) AddFields(m *Fields) *InsertClause

AddFields add fields to insert clause

func (*InsertClause) AddRaw 

func (q *InsertClause) AddRaw(field string, raw string) *InsertClause

AddRaw add raw data to insert clause with given field and raw string.

func (*InsertClause) AddSelect 

func (q *InsertClause) AddSelect(field string, Select *SelectQuery) *InsertClause

AddSelect add select to field

func (*InsertClause) QueryArgs 

func (q *InsertClause) QueryArgs() []interface{}

QueryArgs return query args

func (*InsertClause) QueryCommand 

func (q *InsertClause) QueryCommand() string

QueryCommand return query command

func (*InsertClause) WithSelect 

func (q *InsertClause) WithSelect(s *SelectQuery) *InsertClause

WithSelect conect insert clause with select. Insert calause fields will be ignored after select setted.

type InsertQuery 

type InsertQuery struct {
	Builder *Builder
	Insert  *InsertClause
	Other   *PlainQuery
}

InsertQuery create new insert query.

func (*InsertQuery) Query 

func (i *InsertQuery) Query() *PlainQuery

Query convert query to plain query.

type JoinClause 

type JoinClause struct {
	Builder *Builder
	// Data join data list
	Data []*JoinData
}

JoinClause query struct

func (*JoinClause) InnerJoin 

func (q *JoinClause) InnerJoin() *JoinData

InnerJoin set type of join clause to INNER

func (*JoinClause) LeftJoin 

func (q *JoinClause) LeftJoin() *JoinData

LeftJoin set type of join clause to LEFT

func (*JoinClause) QueryArgs 

func (q *JoinClause) QueryArgs() []interface{}

QueryArgs return query args

func (*JoinClause) QueryCommand 

func (q *JoinClause) QueryCommand() string

QueryCommand return query command

func (*JoinClause) RightJoin 

func (q *JoinClause) RightJoin() *JoinData

RightJoin set type of join clause to RIGHT

type JoinData 

type JoinData struct {
	Builder *Builder
	// Type join type
	Type string
	// TableJoin table struct.
	// Table[0]:table name
	//Table[1]:table alias
	Table [2]string
	// Condition join condition
	Condition *PlainQuery
}

JoinData join clause struct

func (*JoinData) Alias 

func (d *JoinData) Alias(alias string, tableName string) *JoinData

Alias add joined table with given alias.

func (*JoinData) On 

func (d *JoinData) On(condition *PlainQuery) *JoinData

On add On condition

func (*JoinData) OnEqual 

func (d *JoinData) OnEqual(field1 string, field2 string) *JoinData

OnEqual On add On condition which given fieds equal

func (*JoinData) QueryArgs 

func (d *JoinData) QueryArgs() []interface{}

QueryArgs return query args

func (*JoinData) QueryCommand 

func (d *JoinData) QueryCommand() string

QueryCommand return query command

type LimitClause 

type LimitClause struct {

	// Limit sql limit arg
	Limit *int
	// Offset sql offset arg
	Offset *int
	// contains filtered or unexported fields
}

LimitClause limit clause struct

func (*LimitClause) QueryArgs 

func (q *LimitClause) QueryArgs() []interface{}

QueryArgs return query args

func (*LimitClause) QueryCommand 

func (q *LimitClause) QueryCommand() string

QueryCommand return query command

func (*LimitClause) SetLimit 

func (q *LimitClause) SetLimit(l int) *LimitClause

SetLimit set limit clause linut

func (*LimitClause) SetOffset 

func (q *LimitClause) SetOffset(o int) *LimitClause

SetOffset set limit clause offset

type Order 

type Order struct {
	// Field order field
	Field string
	//  Asc order field in asc or not
	Asc bool
}

Order order data struct

type OrderByClause 

type OrderByClause struct {

	// Orders order list
	Orders []Order
	// contains filtered or unexported fields
}

OrderByClause order by clause struct

func (*OrderByClause) Add 

func (q *OrderByClause) Add(field string, asc bool) *OrderByClause

Add add new order to clause with given field and order.

func (*OrderByClause) QueryArgs 

func (q *OrderByClause) QueryArgs() []interface{}

QueryArgs return query args

func (*OrderByClause) QueryCommand 

func (q *OrderByClause) QueryCommand() string

QueryCommand return query command

type PlainQuery 

type PlainQuery struct {
	Builder *Builder
	// Command query command
	Command string
	// Args qyert args
	Args []interface{}
}

PlainQuery plain query struct

func (*PlainQuery) And 

func (q *PlainQuery) And(qs ...Query) *PlainQuery

And concat query with given query list by AND operation

func (*PlainQuery) Exec 

func (q *PlainQuery) Exec(db DB) (sql.Result, error)

Exec exec query in given db

func (*PlainQuery) MustExec 

func (q *PlainQuery) MustExec(db DB) sql.Result

MustExec exec query in given db. Panic if any error raised.

func (*PlainQuery) Or 

func (q *PlainQuery) Or(qs ...Query) *PlainQuery

Or concat query with given query list by OR operation

func (*PlainQuery) QueryArgs 

func (q *PlainQuery) QueryArgs() []interface{}

QueryArgs return query args

func (*PlainQuery) QueryCommand 

func (q *PlainQuery) QueryCommand() string

QueryCommand return query command

func (*PlainQuery) QueryRow 

func (q *PlainQuery) QueryRow(db DB) *sql.Row

QueryRow query rowsfrom db with given query. query will be convert by builder driver.

func (*PlainQuery) QueryRows 

func (q *PlainQuery) QueryRows(db DB) (*sql.Rows, error)

QueryRows query rows from db with given query. query will be convert by builder driver.

type Query 

type Query interface {
	// QueryCommand return query command
	QueryCommand() string
	// QueryArgs return query args
	QueryArgs() []interface{}
}

Query sql query interface

type QueryData 

type QueryData struct {
	// Field data field
	Field string
	// Data data value
	Data []interface{}
	// Raw data raw value.
	// if raw is setted,Data field will be ignored.
	Raw string
}

QueryData query data struct

type ResultScanner 

type ResultScanner interface {
	Scan(dest ...interface{}) error
}

ResultScanner select result scanner interface

type SelectClause 

type SelectClause struct {
	Builder *Builder
	Prefix  *PlainQuery
	Fields  []string
	// contains filtered or unexported fields
}

SelectClause select clause struct

func (*SelectClause) Add 

func (q *SelectClause) Add(fields ...string) *SelectClause

Add add field to select clause

func (*SelectClause) AddFields 

func (q *SelectClause) AddFields(m *Fields) *SelectClause

AddFields add fields to select clause

func (*SelectClause) AddRaw 

func (q *SelectClause) AddRaw(fields ...interface{}) *SelectClause

AddRaw add raw fields to select clause

func (*SelectClause) AddSelect 

func (q *SelectClause) AddSelect(Select *SelectQuery) *SelectClause

AddSelect add select subquery to select clause

func (*SelectClause) QueryArgs 

func (q *SelectClause) QueryArgs() []interface{}

QueryArgs return query args

func (*SelectClause) QueryCommand 

func (q *SelectClause) QueryCommand() string

QueryCommand return query command

func (*SelectClause) Result 

func (q *SelectClause) Result() *SelectResult

Result return select result with select clause

type SelectQuery 

type SelectQuery struct {
	Builder *Builder
	Select  *SelectClause
	From    *FromClause
	Join    *JoinClause
	Where   *WhereClause
	GroupBy *GroupByClause
	Having  *HavingClause
	OrderBy *OrderByClause
	Limit   *LimitClause
	Other   *PlainQuery
}

SelectQuery select query struct.

func (*SelectQuery) Query 

func (s *SelectQuery) Query() *PlainQuery

Query convert select query to plain query.

func (*SelectQuery) QueryArgs 

func (s *SelectQuery) QueryArgs() []interface{}

QueryArgs return query args

func (*SelectQuery) QueryCommand 

func (s *SelectQuery) QueryCommand() string

QueryCommand return query command

func (*SelectQuery) QueryRow 

func (s *SelectQuery) QueryRow(db DB) *sql.Row

QueryRow query rowsfrom db with given query. query will be convert by builder driver.

func (*SelectQuery) QueryRows 

func (s *SelectQuery) QueryRows(db DB) (*sql.Rows, error)

QueryRows query rows from db with given query. query will be convert by builder driver.

func (*SelectQuery) Result 

func (s *SelectQuery) Result() *SelectResult

Result return select result

type SelectResult 

type SelectResult struct {
	Fields []string
	// contains filtered or unexported fields
}

SelectResult select result struct

func NewSelectResult 

func NewSelectResult(fields []string) *SelectResult

NewSelectResult create select result with given fields

func (*SelectResult) Bind 

func (r *SelectResult) Bind(field string, pointer interface{}) *SelectResult

Bind bind field and value pointer to select result.

func (*SelectResult) BindFields 

func (r *SelectResult) BindFields(m *Fields) *SelectResult

BindFields bind fields to select result

func (*SelectResult) Pointers 

func (r *SelectResult) Pointers() []interface{}

Pointers return field pointers

func (*SelectResult) ScanFrom 

func (r *SelectResult) ScanFrom(s ResultScanner) error

ScanFrom scan data with result scanner

type UpdateClause 

type UpdateClause struct {
	Builder *Builder
	// Prefix prefix query
	Prefix *PlainQuery
	// TableName table name
	TableName string
	// Data update query data list
	Data []QueryData
}

UpdateClause update clause struct

func (*UpdateClause) Add 

func (q *UpdateClause) Add(field string, data interface{}) *UpdateClause

Add add data with given field name to update clause

func (*UpdateClause) AddFields 

func (q *UpdateClause) AddFields(m *Fields) *UpdateClause

AddFields add fields to update clause

func (*UpdateClause) AddRaw 

func (q *UpdateClause) AddRaw(field string, raw string) *UpdateClause

AddRaw add raw data to given field Raw data will not be esaped. Dont add unsafe data by this method.

func (*UpdateClause) AddSelect 

func (q *UpdateClause) AddSelect(field string, Select *SelectQuery) *UpdateClause

AddSelect add subquery selecto with given field name to update clause

func (*UpdateClause) QueryArgs 

func (q *UpdateClause) QueryArgs() []interface{}

QueryArgs return query args

func (*UpdateClause) QueryCommand 

func (q *UpdateClause) QueryCommand() string

QueryCommand return query command

type UpdateQuery 

type UpdateQuery struct {
	Builder *Builder
	Update  *UpdateClause
	Where   *WhereClause
	Other   *PlainQuery
}

UpdateQuery update query struct

func (*UpdateQuery) Query 

func (u *UpdateQuery) Query() *PlainQuery

Query convert update query to plain query.

func (*UpdateQuery) QueryArgs 

func (u *UpdateQuery) QueryArgs() []interface{}

QueryArgs return query args

func (*UpdateQuery) QueryCommand 

func (u *UpdateQuery) QueryCommand() string

QueryCommand return query command

type WhereClause 

type WhereClause struct {
	Builder *Builder
	// Condition where condition
	Condition *PlainQuery
}

WhereClause where clause struct

func (*WhereClause) QueryArgs 

func (q *WhereClause) QueryArgs() []interface{}

QueryArgs return query args

func (*WhereClause) QueryCommand 

func (q *WhereClause) QueryCommand() string

QueryCommand return query command

Source Files

View all Source files

Directories

Path Synopsis
drivers
mssql
mysql
postgres
sqlite

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.