querybuilder

package
v1.0.1 Latest Latest
Warning

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

 Go to latest Published: Jul 17, 2019 License: MIT, MIT Imports: 8 Imported by: 0

README

querybuilder SQL 语句拼接器

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

使用方法

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

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

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

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

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

github.com/herb-go/herb/model/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

View Source 
var MSSQLDriver = &MSSQLBuilderDriver{}

MSSQLDriver mssql builder driver

View Source 
var PostgreSQLDriver = &PostgreSQLBuilderDriver{}

PostgreSQLDriver postgre sql driver

View Source 
var SqliteDriver = &SqliteBuilderDriver{}

SqliteDriver sqlite driver

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) 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) NewDelete 

func (b *Builder) NewDelete(TableName string) *Delete

NewDelete create new delete query with given table name.s

func (*Builder) NewDeleteClause 

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

NewDeleteClause create new delete clause with given table name.

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) NewInsert 

func (b *Builder) NewInsert(tableName string) *Insert

NewInsert create new insert query.

func (*Builder) NewInsertClause 

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

NewInsertClause create new insert clause with given table name

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) NewSelect 

func (b *Builder) NewSelect() *Select

NewSelect create new select

func (*Builder) NewSelectClause 

func (b *Builder) NewSelectClause() *SelectClause

NewSelectClause create new select clause

func (*Builder) NewUpdate 

func (b *Builder) NewUpdate(tableName string) *Update

NewUpdate create new update query with given table name.

func (*Builder) NewUpdateClause 

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

NewUpdateClause create new update clause 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

type BuilderDriver 

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

BuilderDriver query builder driver interface

type CommonQueryEvents 

type CommonQueryEvents struct {
}

CommonQueryEvents common query events struct

func (CommonQueryEvents) AfterDelete 

func (e CommonQueryEvents) AfterDelete() error

AfterDelete event raised after find

func (CommonQueryEvents) AfterFind 

func (e CommonQueryEvents) AfterFind() error

AfterFind event raised before find

func (CommonQueryEvents) AfterInsert 

func (e CommonQueryEvents) AfterInsert() error

AfterInsert event raised after insert

func (CommonQueryEvents) AfterUpdate 

func (e CommonQueryEvents) AfterUpdate() error

AfterUpdate event raised after update

func (CommonQueryEvents) BeforeInsert 

func (e CommonQueryEvents) BeforeInsert() error

BeforeInsert event raised before insert

func (CommonQueryEvents) BeforeUpdate 

func (e CommonQueryEvents) BeforeUpdate() error

BeforeUpdate event raised before update

type CommonTask added in v1.0.1 

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

func (*CommonTask) DB added in v1.0.1 

func (t *CommonTask) DB() DB

func (*CommonTask) EmitSuccess added in v1.0.1 

func (t *CommonTask) EmitSuccess() error

func (*CommonTask) OnSuccess added in v1.0.1 

func (t *CommonTask) OnSuccess(f func() error)

func (*CommonTask) SetDB added in v1.0.1 

func (t *CommonTask) SetDB(db DB)

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 DBTable 

type DBTable interface {
	DB
	DB() *sql.DB
	TableName() string
	Alias() string
	SetAlias(string)
	Driver() string
}

DBTable database table interface

type Delete 

type Delete 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
}

Delete delete query

func (*Delete) Query 

func (d *Delete) Query() *PlainQuery

Query return plain query

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 DeleteTask added in v1.0.1 

type DeleteTask struct {
	*Delete
	CommonTask
}

func NewDeleteTask added in v1.0.1 

func NewDeleteTask(q *Delete, db DB) *DeleteTask

func (*DeleteTask) Exec added in v1.0.1 

func (t *DeleteTask) Exec() (sql.Result, error)

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) 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.

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 Insert 

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

Insert create new insert query.

func (*Insert) Query 

func (i *Insert) Query() *PlainQuery

Query convert query to plain query.

type InsertClause 

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

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 *Select) *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 *Select) *InsertClause

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

type InsertTask added in v1.0.1 

type InsertTask struct {
	*Insert
	CommonTask
}

func NewInsertTask added in v1.0.1 

func NewInsertTask(q *Insert, db DB) *InsertTask

func (*InsertTask) Exec added in v1.0.1 

func (t *InsertTask) Exec() (sql.Result, error)

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 {
	// 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) 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 MSSQLBuilderDriver 

type MSSQLBuilderDriver struct {
	EmptyBuilderDriver
}

MSSQLBuilderDriver mssql bilder driver struct

func (*MSSQLBuilderDriver) LimitArgBuilder 

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

LimitArgBuilder build limit args with given limit query.

func (*MSSQLBuilderDriver) LimitCommandBuilder 

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

LimitCommandBuilder build limit command with given limit query.

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 PostgreSQLBuilderDriver 

type PostgreSQLBuilderDriver struct {
	EmptyBuilderDriver
}

PostgreSQLBuilderDriver posgresql builder driver struct

func (PostgreSQLBuilderDriver) ConvertQuery 

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

ConvertQuery convert query to command and args

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 Select 

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

Select select query struct.

func (*Select) Query 

func (s *Select) Query() *PlainQuery

Query convert select query to plain query.

func (*Select) QueryArgs 

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

QueryArgs return query args

func (*Select) QueryCommand 

func (s *Select) QueryCommand() string

QueryCommand return query command

func (*Select) QueryRow 

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

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

func (*Select) QueryRows 

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

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

func (*Select) Result 

func (s *Select) Result() *SelectResult

Result return select result

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 *Select) *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 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 SelectTask added in v1.0.1 

type SelectTask struct {
	*Select
	CommonTask
}

func NewSelectTask added in v1.0.1 

func NewSelectTask(q *Select, db DB) *SelectTask

func (*SelectTask) QueryRow added in v1.0.1 

func (t *SelectTask) QueryRow() *sql.Row

func (*SelectTask) QueryRows added in v1.0.1 

func (t *SelectTask) QueryRows() (*sql.Rows, error)

type SqliteBuilderDriver 

type SqliteBuilderDriver struct {
	EmptyBuilderDriver
}

SqliteBuilderDriver sqlite builder driver

type Table 

type Table struct {
	DBTable
}

Table query table

func NewTable 

func NewTable(dbtable DBTable) *Table

NewTable create new query table with given database table

func (*Table) BuildCount 

func (t *Table) BuildCount() *Select

BuildCount : build count select query for table

func (*Table) Count 

func (t *Table) Count(Select *Select) (int, error)

Count : count from table by given select t.QueryBuilder().

func (*Table) FieldAlias 

func (t *Table) FieldAlias(field string) string

FieldAlias return field name with table alias.

func (*Table) NewDelete 

func (t *Table) NewDelete() *Delete

NewDelete : build delete query for table node

func (*Table) NewInsert 

func (t *Table) NewInsert() *Insert

NewInsert : new insert query for table node

func (*Table) NewSelect 

func (t *Table) NewSelect() *Select

NewSelect : create select query for table

func (*Table) NewUpdate 

func (t *Table) NewUpdate() *Update

NewUpdate : new update query for table

func (*Table) QueryBuilder 

func (t *Table) QueryBuilder() *Builder

QueryBuilder return querybuilder of table

type Task added in v1.0.1 

type Task interface {
	SetDB(DB)
	DB() DB
	OnSuccess(func() error)
	EmitSuccess() error
}

type Update 

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

Update update query struct

func (*Update) Query 

func (u *Update) Query() *PlainQuery

Query convert update query to plain query.

func (*Update) QueryArgs 

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

QueryArgs return query args

func (*Update) QueryCommand 

func (u *Update) QueryCommand() string

QueryCommand return query command

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 *Select) *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 UpdateTask added in v1.0.1 

type UpdateTask struct {
	*Update
	CommonTask
}

func NewUpdateTask added in v1.0.1 

func NewUpdateTask(q *Update, db DB) *UpdateTask

func (*UpdateTask) Exec added in v1.0.1 

func (t *UpdateTask) Exec() (sql.Result, error)

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

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.