bun

package module
v0.1.3 Latest Latest
Warning

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

 Go to latest Published: May 19, 2021 License: BSD-2-Clause Imports: 18 Imported by: 946

README

Tasty ORM for sql.DB

build workflow PkgGoDev Documentation Chat

Installation

go get github.com/uptrace/bun

Quickstart

First you need to create a *sql.DB. Here we using the SQLite3 driver.

import _ "github.com/mattn/go-sqlite3"

sqldb, err := sql.Open("sqlite3", ":memory:?cache=shared")
if err != nil {
	panic(err)
}

And then create a *bun.DB on top of it using the corresponding SQLite dialect:

import (
	"github.com/uptrace/bun"
	"github.com/uptrace/bun/dialect/sqlitedialect"
)

db := bun.NewDB(sqldb, sqlitedialect.New())

Now you are ready to issue some queries:

type User struct {
	ID	 int64
	Name string
}

user := new(User)
err := db.NewSelect().
	Model(user).
	Where("name != ?", "").
	OrderExpr("id ASC").
	Limit(1).
	Scan(ctx)

The code above is equivalent to:

query := "SELECT id, name FROM users AS user WHERE name != '' ORDER BY id ASC LIMIT 1"

rows, err := sqldb.QueryContext(ctx, query)
if err != nil {
	panic(err)
}

if rows.Next() {
	user := new(User)
	if err := db.ScanRow(ctx, rows, user); err != nil {
		panic(err)
	}
}

if err := rows.Err(); err != nil {
    panic(err)
}

For more details, please check docs.

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AddColumnQuery 

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

func NewAddColumnQuery 

func NewAddColumnQuery(db *DB) *AddColumnQuery

func (*AddColumnQuery) AppendArg 

func (q *AddColumnQuery) AppendArg(fmter schema.Formatter, b []byte, name string) ([]byte, bool)

func (*AddColumnQuery) AppendQuery 

func (q *AddColumnQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error)

func (*AddColumnQuery) ColumnExpr 

func (q *AddColumnQuery) ColumnExpr(query string, args ...interface{}) *AddColumnQuery

func (*AddColumnQuery) DB 

func (q *AddColumnQuery) DB(db DBI) *AddColumnQuery

func (*AddColumnQuery) Exec 

func (q *AddColumnQuery) Exec(ctx context.Context, dest ...interface{}) (res sql.Result, err error)

func (*AddColumnQuery) GetDB 

func (q *AddColumnQuery) GetDB() *DB

func (*AddColumnQuery) Model 

func (q *AddColumnQuery) Model(model interface{}) *AddColumnQuery

func (*AddColumnQuery) ModelTableExpr 

func (q *AddColumnQuery) ModelTableExpr(query string, args ...interface{}) *AddColumnQuery

func (*AddColumnQuery) Table 

func (q *AddColumnQuery) Table(tables ...string) *AddColumnQuery

func (*AddColumnQuery) TableExpr 

func (q *AddColumnQuery) TableExpr(query string, args ...interface{}) *AddColumnQuery

type AfterCreateTableQueryHook 

type AfterCreateTableQueryHook interface {
	AfterCreateTableQuery(ctx context.Context, query *CreateTableQuery) error
}

type AfterDeleteHook 

type AfterDeleteHook = schema.AfterDeleteHook

type AfterDropTableQueryHook 

type AfterDropTableQueryHook interface {
	AfterDropTableQuery(ctx context.Context, query *DropTableQuery) error
}

type AfterInsertHook 

type AfterInsertHook = schema.AfterInsertHook

type AfterScanHook 

type AfterScanHook = schema.AfterScanHook

type AfterSelectHook 

type AfterSelectHook = schema.AfterSelectHook

type AfterUpdateHook 

type AfterUpdateHook = schema.AfterUpdateHook

type BaseModel 

type BaseModel struct{}

type BeforeCreateTableQueryHook 

type BeforeCreateTableQueryHook interface {
	BeforeCreateTableQuery(ctx context.Context, query *CreateTableQuery) error
}

type BeforeDeleteHook 

type BeforeDeleteHook = schema.BeforeDeleteHook

type BeforeDropTableQueryHook 

type BeforeDropTableQueryHook interface {
	BeforeDropTableQuery(ctx context.Context, query *DropTableQuery) error
}

type BeforeInsertHook 

type BeforeInsertHook = schema.BeforeInsertHook

type BeforeScanHook 

type BeforeScanHook = schema.BeforeScanHook

type BeforeUpdateHook 

type BeforeUpdateHook = schema.BeforeUpdateHook

type Conn 

type Conn struct {
	*sql.Conn
	// contains filtered or unexported fields
}

func (Conn) ExecContext 

func (c Conn) ExecContext(
	ctx context.Context, query string, args ...interface{},
) (sql.Result, error)

func (Conn) QueryContext 

func (c Conn) QueryContext(
	ctx context.Context, query string, args ...interface{},
) (*sql.Rows, error)

func (Conn) QueryRowContext 

func (c Conn) QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row

type CreateIndexQuery 

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

func NewCreateIndexQuery 

func NewCreateIndexQuery(db *DB) *CreateIndexQuery

func (*CreateIndexQuery) AppendQuery 

func (q *CreateIndexQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error)

func (*CreateIndexQuery) Column 

func (q *CreateIndexQuery) Column(columns ...string) *CreateIndexQuery

func (*CreateIndexQuery) ColumnExpr 

func (q *CreateIndexQuery) ColumnExpr(query string, args ...interface{}) *CreateIndexQuery

func (*CreateIndexQuery) Concurrently 

func (q *CreateIndexQuery) Concurrently() *CreateIndexQuery

func (*CreateIndexQuery) DB 

func (q *CreateIndexQuery) DB(db DBI) *CreateIndexQuery

func (*CreateIndexQuery) ExcludeColumn 

func (q *CreateIndexQuery) ExcludeColumn(columns ...string) *CreateIndexQuery

func (*CreateIndexQuery) Exec 

func (q *CreateIndexQuery) Exec(
	ctx context.Context, dest ...interface{},
) (res sql.Result, err error)

func (*CreateIndexQuery) IfNotExists 

func (q *CreateIndexQuery) IfNotExists() *CreateIndexQuery

func (*CreateIndexQuery) Include 

func (q *CreateIndexQuery) Include(columns ...string) *CreateIndexQuery

func (*CreateIndexQuery) IncludeExpr 

func (q *CreateIndexQuery) IncludeExpr(query string, args ...interface{}) *CreateIndexQuery

func (*CreateIndexQuery) Index 

func (q *CreateIndexQuery) Index(query string) *CreateIndexQuery

func (*CreateIndexQuery) IndexExpr 

func (q *CreateIndexQuery) IndexExpr(query string, args ...interface{}) *CreateIndexQuery

func (*CreateIndexQuery) Model 

func (q *CreateIndexQuery) Model(model interface{}) *CreateIndexQuery

func (*CreateIndexQuery) ModelTableExpr 

func (q *CreateIndexQuery) ModelTableExpr(query string, args ...interface{}) *CreateIndexQuery

func (*CreateIndexQuery) Table 

func (q *CreateIndexQuery) Table(tables ...string) *CreateIndexQuery

func (*CreateIndexQuery) TableExpr 

func (q *CreateIndexQuery) TableExpr(query string, args ...interface{}) *CreateIndexQuery

func (*CreateIndexQuery) Unique 

func (q *CreateIndexQuery) Unique() *CreateIndexQuery

func (*CreateIndexQuery) Using 

func (q *CreateIndexQuery) Using(query string, args ...interface{}) *CreateIndexQuery

func (*CreateIndexQuery) Where 

func (q *CreateIndexQuery) Where(query string, args ...interface{}) *CreateIndexQuery

func (*CreateIndexQuery) WhereGroup 

func (q *CreateIndexQuery) WhereGroup(sep string, fn func(*WhereQuery)) *CreateIndexQuery

func (*CreateIndexQuery) WhereOr 

func (q *CreateIndexQuery) WhereOr(query string, args ...interface{}) *CreateIndexQuery

type CreateTableQuery 

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

func NewCreateTableQuery 

func NewCreateTableQuery(db *DB) *CreateTableQuery

func (*CreateTableQuery) AppendArg 

func (q *CreateTableQuery) AppendArg(fmter schema.Formatter, b []byte, name string) ([]byte, bool)

func (*CreateTableQuery) AppendQuery 

func (q *CreateTableQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error)

func (*CreateTableQuery) DB 

func (q *CreateTableQuery) DB(db DBI) *CreateTableQuery

func (*CreateTableQuery) Exec 

func (q *CreateTableQuery) Exec(ctx context.Context, dest ...interface{}) (res sql.Result, _ error)

func (*CreateTableQuery) GetDB 

func (q *CreateTableQuery) GetDB() *DB

func (*CreateTableQuery) IfNotExists 

func (q *CreateTableQuery) IfNotExists() *CreateTableQuery

func (*CreateTableQuery) Model 

func (q *CreateTableQuery) Model(model interface{}) *CreateTableQuery

func (*CreateTableQuery) ModelTableExpr 

func (q *CreateTableQuery) ModelTableExpr(query string, args ...interface{}) *CreateTableQuery

func (*CreateTableQuery) Table 

func (q *CreateTableQuery) Table(tables ...string) *CreateTableQuery

func (*CreateTableQuery) TableExpr 

func (q *CreateTableQuery) TableExpr(query string, args ...interface{}) *CreateTableQuery

func (*CreateTableQuery) Temp 

func (q *CreateTableQuery) Temp() *CreateTableQuery

func (*CreateTableQuery) Varchar 

func (q *CreateTableQuery) Varchar(n int) *CreateTableQuery

func (*CreateTableQuery) WithFKConstraints 

func (q *CreateTableQuery) WithFKConstraints() *CreateTableQuery

type DB 

type DB struct {
	*sql.DB
	// contains filtered or unexported fields
}

func NewDB 

func NewDB(sqldb *sql.DB, dialect schema.Dialect, opts ...DBOption) *DB

func (*DB) AddQueryHook 

func (db *DB) AddQueryHook(hook QueryHook)

func (*DB) Begin 

func (db *DB) Begin() (Tx, error)

func (*DB) BeginTx 

func (db *DB) BeginTx(ctx context.Context, opts *sql.TxOptions) (Tx, error)

func (*DB) Conn 

func (db *DB) Conn(ctx context.Context) (Conn, error)

func (*DB) Dialect 

func (db *DB) Dialect() schema.Dialect

func (*DB) Exec 

func (db *DB) Exec(query string, args ...interface{}) (sql.Result, error)

func (*DB) ExecContext 

func (db *DB) ExecContext(
	ctx context.Context, query string, args ...interface{},
) (sql.Result, error)

func (*DB) Formatter 

func (db *DB) Formatter() schema.Formatter

func (*DB) NamedArg 

func (db *DB) NamedArg(name string) interface{}

func (*DB) NewAddColumn 

func (db *DB) NewAddColumn() *AddColumnQuery

func (*DB) NewCreateIndex 

func (db *DB) NewCreateIndex() *CreateIndexQuery

func (*DB) NewCreateTable 

func (db *DB) NewCreateTable() *CreateTableQuery

func (*DB) NewDelete 

func (db *DB) NewDelete() *DeleteQuery

func (*DB) NewDropColumn 

func (db *DB) NewDropColumn() *DropColumnQuery

func (*DB) NewDropIndex 

func (db *DB) NewDropIndex() *DropIndexQuery

func (*DB) NewDropTable 

func (db *DB) NewDropTable() *DropTableQuery

func (*DB) NewInsert 

func (db *DB) NewInsert() *InsertQuery

func (*DB) NewSelect 

func (db *DB) NewSelect() *SelectQuery

func (*DB) NewTruncateTable 

func (db *DB) NewTruncateTable() *TruncateTableQuery

func (*DB) NewUpdate 

func (db *DB) NewUpdate() *UpdateQuery

func (*DB) NewValues 

func (db *DB) NewValues(model interface{}) *ValuesQuery

func (*DB) Prepare 

func (db *DB) Prepare(query string) (Stmt, error)

func (*DB) PrepareContext 

func (db *DB) PrepareContext(ctx context.Context, query string) (Stmt, error)

func (*DB) Query 

func (db *DB) Query(query string, args ...interface{}) (*sql.Rows, error)

func (*DB) QueryContext 

func (db *DB) QueryContext(
	ctx context.Context, query string, args ...interface{},
) (*sql.Rows, error)

func (*DB) QueryRow 

func (db *DB) QueryRow(query string, args ...interface{}) *sql.Row

func (*DB) QueryRowContext 

func (db *DB) QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row

func (*DB) RegisterModel 

func (db *DB) RegisterModel(models ...interface{})

func (*DB) ScanRow 

func (db *DB) ScanRow(ctx context.Context, rows *sql.Rows, dest ...interface{}) error

func (*DB) ScanRows 

func (db *DB) ScanRows(ctx context.Context, rows *sql.Rows, dest ...interface{}) error

func (*DB) Stats 

func (db *DB) Stats() DBStats

func (*DB) Table 

func (db *DB) Table(typ reflect.Type) *schema.Table

func (*DB) WithNamedArg 

func (db *DB) WithNamedArg(name string, value interface{}) *DB

type DBI 

type DBI interface {
	QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error)
	ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error)
}

type DBOption 

type DBOption func(db *DB)

func WithDiscardUnknownColumns added in v0.1.3 

func WithDiscardUnknownColumns() DBOption

type DBStats 

type DBStats struct {
	Queries uint64
	Errors  uint64
}

type DeleteQuery 

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

func NewDeleteQuery 

func NewDeleteQuery(db *DB) *DeleteQuery

func (*DeleteQuery) AppendQuery 

func (q *DeleteQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error)

func (*DeleteQuery) Apply 

func (q *DeleteQuery) Apply(fn func(*DeleteQuery) *DeleteQuery) *DeleteQuery

Apply calls the fn passing the DeleteQuery as an argument.

func (*DeleteQuery) DB 

func (q *DeleteQuery) DB(db DBI) *DeleteQuery

func (*DeleteQuery) Exec 

func (q *DeleteQuery) Exec(ctx context.Context, dest ...interface{}) (res sql.Result, _ error)

func (*DeleteQuery) ForceDelete 

func (q *DeleteQuery) ForceDelete(
	ctx context.Context, dest ...interface{},
) (res sql.Result, err error)

func (*DeleteQuery) Model 

func (q *DeleteQuery) Model(model interface{}) *DeleteQuery

func (*DeleteQuery) ModelTableExpr 

func (q *DeleteQuery) ModelTableExpr(query string, args ...interface{}) *DeleteQuery

func (*DeleteQuery) Returning 

func (q *DeleteQuery) Returning(query string, args ...interface{}) *DeleteQuery

Returning adds a RETURNING clause to the query.

To suppress the auto-generated RETURNING clause, use `Returning("NULL")`.

func (*DeleteQuery) Table 

func (q *DeleteQuery) Table(tables ...string) *DeleteQuery

func (*DeleteQuery) TableExpr 

func (q *DeleteQuery) TableExpr(query string, args ...interface{}) *DeleteQuery

func (*DeleteQuery) Where 

func (q *DeleteQuery) Where(query string, args ...interface{}) *DeleteQuery

func (*DeleteQuery) WhereAllWithDeleted 

func (q *DeleteQuery) WhereAllWithDeleted() *DeleteQuery

func (*DeleteQuery) WhereDeleted 

func (q *DeleteQuery) WhereDeleted() *DeleteQuery

func (*DeleteQuery) WhereGroup 

func (q *DeleteQuery) WhereGroup(sep string, fn func(*WhereQuery)) *DeleteQuery

func (*DeleteQuery) WhereOr 

func (q *DeleteQuery) WhereOr(query string, args ...interface{}) *DeleteQuery

func (*DeleteQuery) WherePK 

func (q *DeleteQuery) WherePK() *DeleteQuery

WherePK adds conditions based on the model primary keys. Usually it is the same as: 

Where("id = ?id")

func (*DeleteQuery) With 

func (q *DeleteQuery) With(name string, query schema.QueryAppender) *DeleteQuery

type DropColumnQuery 

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

func NewDropColumnQuery 

func NewDropColumnQuery(db *DB) *DropColumnQuery

func (*DropColumnQuery) AppendArg 

func (q *DropColumnQuery) AppendArg(fmter schema.Formatter, b []byte, name string) ([]byte, bool)

func (*DropColumnQuery) AppendQuery 

func (q *DropColumnQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error)

func (*DropColumnQuery) Column 

func (q *DropColumnQuery) Column(columns ...string) *DropColumnQuery

func (*DropColumnQuery) ColumnExpr 

func (q *DropColumnQuery) ColumnExpr(query string, args ...interface{}) *DropColumnQuery

func (*DropColumnQuery) DB 

func (q *DropColumnQuery) DB(db DBI) *DropColumnQuery

func (*DropColumnQuery) Exec 

func (q *DropColumnQuery) Exec(ctx context.Context, dest ...interface{}) (res sql.Result, err error)

func (*DropColumnQuery) GetDB 

func (q *DropColumnQuery) GetDB() *DB

func (*DropColumnQuery) Model 

func (q *DropColumnQuery) Model(model interface{}) *DropColumnQuery

func (*DropColumnQuery) ModelTableExpr 

func (q *DropColumnQuery) ModelTableExpr(query string, args ...interface{}) *DropColumnQuery

func (*DropColumnQuery) Table 

func (q *DropColumnQuery) Table(tables ...string) *DropColumnQuery

func (*DropColumnQuery) TableExpr 

func (q *DropColumnQuery) TableExpr(query string, args ...interface{}) *DropColumnQuery

type DropIndexQuery 

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

func NewDropIndexQuery 

func NewDropIndexQuery(db *DB) *DropIndexQuery

func (*DropIndexQuery) AppendArg 

func (q *DropIndexQuery) AppendArg(fmter schema.Formatter, b []byte, name string) ([]byte, bool)

func (*DropIndexQuery) AppendQuery 

func (q *DropIndexQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error)

func (*DropIndexQuery) Concurrently 

func (q *DropIndexQuery) Concurrently() *DropIndexQuery

func (*DropIndexQuery) DB 

func (q *DropIndexQuery) DB(db DBI) *DropIndexQuery

func (*DropIndexQuery) Exec 

func (q *DropIndexQuery) Exec(ctx context.Context, dest ...interface{}) (res sql.Result, err error)

func (*DropIndexQuery) GetDB 

func (q *DropIndexQuery) GetDB() *DB

func (*DropIndexQuery) IfExists 

func (q *DropIndexQuery) IfExists() *DropIndexQuery

func (*DropIndexQuery) Index 

func (q *DropIndexQuery) Index(query string, args ...interface{}) *DropIndexQuery

func (*DropIndexQuery) Model 

func (q *DropIndexQuery) Model(model interface{}) *DropIndexQuery

func (*DropIndexQuery) Restrict 

func (q *DropIndexQuery) Restrict() *DropIndexQuery

type DropTableQuery 

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

func NewDropTableQuery 

func NewDropTableQuery(db *DB) *DropTableQuery

func (*DropTableQuery) AppendArg 

func (q *DropTableQuery) AppendArg(fmter schema.Formatter, b []byte, name string) ([]byte, bool)

func (*DropTableQuery) AppendQuery 

func (q *DropTableQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error)

func (*DropTableQuery) DB 

func (q *DropTableQuery) DB(db DBI) *DropTableQuery

func (*DropTableQuery) Exec 

func (q *DropTableQuery) Exec(ctx context.Context, dest ...interface{}) (res sql.Result, _ error)

func (*DropTableQuery) GetDB 

func (q *DropTableQuery) GetDB() *DB

func (*DropTableQuery) IfExists 

func (q *DropTableQuery) IfExists() *DropTableQuery

func (*DropTableQuery) Model 

func (q *DropTableQuery) Model(model interface{}) *DropTableQuery

func (*DropTableQuery) Restrict 

func (q *DropTableQuery) Restrict() *DropTableQuery

func (*DropTableQuery) Table 

func (q *DropTableQuery) Table(tables ...string) *DropTableQuery

func (*DropTableQuery) TableExpr 

func (q *DropTableQuery) TableExpr(query string, args ...interface{}) *DropTableQuery

type Ident 

type Ident = schema.Ident

type InValues 

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

func In 

func In(slice interface{}) InValues

func (InValues) AppendQuery 

func (in InValues) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error)

type InsertQuery 

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

func NewInsertQuery 

func NewInsertQuery(db *DB) *InsertQuery

func (*InsertQuery) AppendQuery 

func (q *InsertQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error)

func (*InsertQuery) Apply 

func (q *InsertQuery) Apply(fn func(*InsertQuery) *InsertQuery) *InsertQuery

Apply calls the fn passing the SelectQuery as an argument.

func (*InsertQuery) Column 

func (q *InsertQuery) Column(columns ...string) *InsertQuery

func (*InsertQuery) DB 

func (q *InsertQuery) DB(db DBI) *InsertQuery

func (*InsertQuery) Exec 

func (q *InsertQuery) Exec(ctx context.Context, dest ...interface{}) (res sql.Result, err error)

func (*InsertQuery) Model 

func (q *InsertQuery) Model(model interface{}) *InsertQuery

func (*InsertQuery) ModelTableExpr 

func (q *InsertQuery) ModelTableExpr(query string, args ...interface{}) *InsertQuery

func (*InsertQuery) OnConflict 

func (q *InsertQuery) OnConflict(s string, args ...interface{}) *InsertQuery

func (*InsertQuery) Returning 

func (q *InsertQuery) Returning(query string, args ...interface{}) *InsertQuery

Returning adds a RETURNING clause to the query.

To suppress the auto-generated RETURNING clause, use `Returning("NULL")`.

func (*InsertQuery) Set 

func (q *InsertQuery) Set(query string, args ...interface{}) *InsertQuery

func (*InsertQuery) Table 

func (q *InsertQuery) Table(tables ...string) *InsertQuery

func (*InsertQuery) TableExpr 

func (q *InsertQuery) TableExpr(query string, args ...interface{}) *InsertQuery

func (*InsertQuery) Value 

func (q *InsertQuery) Value(column string, value string, args ...interface{}) *InsertQuery

Value overwrites model value for the column in INSERT and UPDATE queries.

func (*InsertQuery) Where 

func (q *InsertQuery) Where(query string, args ...interface{}) *InsertQuery

func (*InsertQuery) WhereOr 

func (q *InsertQuery) WhereOr(query string, args ...interface{}) *InsertQuery

func (*InsertQuery) With 

func (q *InsertQuery) With(name string, query schema.QueryAppender) *InsertQuery

type NullTime 

type NullTime struct {
	time.Time
}

NullTime is a time.Time wrapper that marshals zero time as JSON null and SQL NULL.

func (NullTime) AppendQuery 

func (tm NullTime) AppendQuery(fmter schema.Formatter, b []byte) ([]byte, error)

func (NullTime) MarshalJSON 

func (tm NullTime) MarshalJSON() ([]byte, error)

func (*NullTime) Scan 

func (tm *NullTime) Scan(src interface{}) error

func (*NullTime) UnmarshalJSON 

func (tm *NullTime) UnmarshalJSON(b []byte) error

type QueryEvent 

type QueryEvent struct {
	DB *DB

	QueryAppender schema.QueryAppender
	Query         []byte
	QueryArgs     []interface{}

	StartTime time.Time
	Result    sql.Result
	Err       error

	Stash map[interface{}]interface{}
}

type QueryHook 

type QueryHook interface {
	BeforeQuery(context.Context, *QueryEvent) context.Context
	AfterQuery(context.Context, *QueryEvent)
}

type Safe 

type Safe = schema.Safe

type SelectQuery 

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

func NewSelectQuery 

func NewSelectQuery(db *DB) *SelectQuery

func (*SelectQuery) AppendQuery 

func (q *SelectQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error)

func (*SelectQuery) Apply 

func (q *SelectQuery) Apply(fn func(*SelectQuery) *SelectQuery) *SelectQuery

Apply calls the fn passing the SelectQuery as an argument.

func (*SelectQuery) Column 

func (q *SelectQuery) Column(columns ...string) *SelectQuery

func (*SelectQuery) ColumnExpr 

func (q *SelectQuery) ColumnExpr(query string, args ...interface{}) *SelectQuery

func (*SelectQuery) Count 

func (q *SelectQuery) Count(ctx context.Context) (int, error)

func (*SelectQuery) DB 

func (q *SelectQuery) DB(db DBI) *SelectQuery

func (*SelectQuery) Distinct 

func (q *SelectQuery) Distinct() *SelectQuery

func (*SelectQuery) DistinctOn 

func (q *SelectQuery) DistinctOn(query string, args ...interface{}) *SelectQuery

func (*SelectQuery) Except 

func (q *SelectQuery) Except(other *SelectQuery) *SelectQuery

func (*SelectQuery) ExceptAll 

func (q *SelectQuery) ExceptAll(other *SelectQuery) *SelectQuery

func (*SelectQuery) ExcludeColumn 

func (q *SelectQuery) ExcludeColumn(columns ...string) *SelectQuery

func (*SelectQuery) Exec 

func (q *SelectQuery) Exec(ctx context.Context, dest ...interface{}) (res sql.Result, err error)

func (*SelectQuery) For 

func (q *SelectQuery) For(s string, args ...interface{}) *SelectQuery

func (*SelectQuery) Group 

func (q *SelectQuery) Group(columns ...string) *SelectQuery

func (*SelectQuery) GroupExpr 

func (q *SelectQuery) GroupExpr(group string, args ...interface{}) *SelectQuery

func (*SelectQuery) Having 

func (q *SelectQuery) Having(having string, args ...interface{}) *SelectQuery

func (*SelectQuery) Intersect 

func (q *SelectQuery) Intersect(other *SelectQuery) *SelectQuery

func (*SelectQuery) IntersectAll 

func (q *SelectQuery) IntersectAll(other *SelectQuery) *SelectQuery

func (*SelectQuery) Join 

func (q *SelectQuery) Join(join string, args ...interface{}) *SelectQuery

func (*SelectQuery) JoinOn 

func (q *SelectQuery) JoinOn(cond string, args ...interface{}) *SelectQuery

func (*SelectQuery) JoinOnOr 

func (q *SelectQuery) JoinOnOr(cond string, args ...interface{}) *SelectQuery

func (*SelectQuery) Limit 

func (q *SelectQuery) Limit(n int) *SelectQuery

func (*SelectQuery) Model 

func (q *SelectQuery) Model(model interface{}) *SelectQuery

func (*SelectQuery) ModelTableExpr 

func (q *SelectQuery) ModelTableExpr(query string, args ...interface{}) *SelectQuery

func (*SelectQuery) Offset 

func (q *SelectQuery) Offset(n int) *SelectQuery

func (*SelectQuery) Order 

func (q *SelectQuery) Order(orders ...string) *SelectQuery

func (*SelectQuery) OrderExpr 

func (q *SelectQuery) OrderExpr(query string, args ...interface{}) *SelectQuery

func (*SelectQuery) Relation 

func (q *SelectQuery) Relation(name string, apply ...func(*SelectQuery) *SelectQuery) *SelectQuery

Relation adds a relation to the query. Relation name can be:

  • RelationName to select all columns,
  • RelationName.column_name,
  • RelationName._ to join relation without selecting relation columns.

func (*SelectQuery) Rows 

func (q *SelectQuery) Rows(ctx context.Context) (*sql.Rows, error)

func (*SelectQuery) Scan 

func (q *SelectQuery) Scan(ctx context.Context, dest ...interface{}) error

func (*SelectQuery) ScanAndCount 

func (q *SelectQuery) ScanAndCount(ctx context.Context, dest ...interface{}) (int, error)

func (*SelectQuery) Table 

func (q *SelectQuery) Table(tables ...string) *SelectQuery

func (*SelectQuery) TableExpr 

func (q *SelectQuery) TableExpr(query string, args ...interface{}) *SelectQuery

func (*SelectQuery) Union 

func (q *SelectQuery) Union(other *SelectQuery) *SelectQuery

func (*SelectQuery) UnionAll 

func (q *SelectQuery) UnionAll(other *SelectQuery) *SelectQuery

func (*SelectQuery) Where 

func (q *SelectQuery) Where(query string, args ...interface{}) *SelectQuery

func (*SelectQuery) WhereAllWithDeleted 

func (q *SelectQuery) WhereAllWithDeleted() *SelectQuery

func (*SelectQuery) WhereDeleted 

func (q *SelectQuery) WhereDeleted() *SelectQuery

func (*SelectQuery) WhereGroup 

func (q *SelectQuery) WhereGroup(sep string, fn func(*WhereQuery)) *SelectQuery

func (*SelectQuery) WhereOr 

func (q *SelectQuery) WhereOr(query string, args ...interface{}) *SelectQuery

func (*SelectQuery) WherePK 

func (q *SelectQuery) WherePK() *SelectQuery

WherePK adds conditions based on the model primary keys. Usually it is the same as: 

Where("id = ?id")

func (*SelectQuery) With 

func (q *SelectQuery) With(name string, query schema.QueryAppender) *SelectQuery

type Stmt 

type Stmt struct {
	*sql.Stmt
}

type TruncateTableQuery 

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

func NewTruncateTableQuery 

func NewTruncateTableQuery(db *DB) *TruncateTableQuery

func (*TruncateTableQuery) AppendArg 

func (q *TruncateTableQuery) AppendArg(fmter schema.Formatter, b []byte, name string) ([]byte, bool)

func (*TruncateTableQuery) AppendQuery 

func (q *TruncateTableQuery) AppendQuery(
	fmter schema.Formatter, b []byte,
) (_ []byte, err error)

func (*TruncateTableQuery) ContinueIdentity 

func (q *TruncateTableQuery) ContinueIdentity() *TruncateTableQuery

func (*TruncateTableQuery) DB 

func (q *TruncateTableQuery) DB(db DBI) *TruncateTableQuery

func (*TruncateTableQuery) Exec 

func (q *TruncateTableQuery) Exec(ctx context.Context, dest ...interface{}) (res sql.Result, _ error)

func (*TruncateTableQuery) GetDB 

func (q *TruncateTableQuery) GetDB() *DB

func (*TruncateTableQuery) Model 

func (q *TruncateTableQuery) Model(model interface{}) *TruncateTableQuery

func (*TruncateTableQuery) Restrict 

func (q *TruncateTableQuery) Restrict() *TruncateTableQuery

func (*TruncateTableQuery) Table 

func (q *TruncateTableQuery) Table(tables ...string) *TruncateTableQuery

func (*TruncateTableQuery) TableExpr 

func (q *TruncateTableQuery) TableExpr(query string, args ...interface{}) *TruncateTableQuery

type Tx 

type Tx struct {
	*sql.Tx
	// contains filtered or unexported fields
}

func (Tx) Exec added in v0.1.3 

func (tx Tx) Exec(query string, args ...interface{}) (sql.Result, error)

func (Tx) ExecContext added in v0.1.3 

func (tx Tx) ExecContext(
	ctx context.Context, query string, args ...interface{},
) (sql.Result, error)

func (Tx) Query added in v0.1.3 

func (tx Tx) Query(query string, args ...interface{}) (*sql.Rows, error)

func (Tx) QueryContext added in v0.1.3 

func (tx Tx) QueryContext(
	ctx context.Context, query string, args ...interface{},
) (*sql.Rows, error)

func (Tx) QueryRow added in v0.1.3 

func (tx Tx) QueryRow(query string, args ...interface{}) *sql.Row

func (Tx) QueryRowContext added in v0.1.3 

func (tx Tx) QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row

type UpdateQuery 

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

func NewUpdateQuery 

func NewUpdateQuery(db *DB) *UpdateQuery

func (*UpdateQuery) AppendQuery 

func (q *UpdateQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error)

func (*UpdateQuery) Apply 

func (q *UpdateQuery) Apply(fn func(*UpdateQuery) *UpdateQuery) *UpdateQuery

Apply calls the fn passing the SelectQuery as an argument.

func (*UpdateQuery) Column 

func (q *UpdateQuery) Column(columns ...string) *UpdateQuery

func (*UpdateQuery) DB 

func (q *UpdateQuery) DB(db DBI) *UpdateQuery

func (*UpdateQuery) Exec 

func (q *UpdateQuery) Exec(ctx context.Context, dest ...interface{}) (res sql.Result, err error)

func (*UpdateQuery) FQN added in v0.1.3 

func (q *UpdateQuery) FQN(name string) Ident

FQN returns a fully qualified column name. For MySQL, it returns the column name with the table alias. For other RDBMS, it returns just the column name.

func (*UpdateQuery) Model 

func (q *UpdateQuery) Model(model interface{}) *UpdateQuery

func (*UpdateQuery) ModelTableExpr 

func (q *UpdateQuery) ModelTableExpr(query string, args ...interface{}) *UpdateQuery

func (*UpdateQuery) Returning 

func (q *UpdateQuery) Returning(query string, args ...interface{}) *UpdateQuery

Returning adds a RETURNING clause to the query.

To suppress the auto-generated RETURNING clause, use `Returning("NULL")`.

func (*UpdateQuery) Set 

func (q *UpdateQuery) Set(query string, args ...interface{}) *UpdateQuery

func (*UpdateQuery) Table 

func (q *UpdateQuery) Table(tables ...string) *UpdateQuery

func (*UpdateQuery) TableExpr 

func (q *UpdateQuery) TableExpr(query string, args ...interface{}) *UpdateQuery

func (*UpdateQuery) Value 

func (q *UpdateQuery) Value(column string, value string, args ...interface{}) *UpdateQuery

Value overwrites model value for the column in INSERT and UPDATE queries.

func (*UpdateQuery) Where 

func (q *UpdateQuery) Where(query string, args ...interface{}) *UpdateQuery

func (*UpdateQuery) WhereAllWithDeleted 

func (q *UpdateQuery) WhereAllWithDeleted() *UpdateQuery

func (*UpdateQuery) WhereDeleted 

func (q *UpdateQuery) WhereDeleted() *UpdateQuery

func (*UpdateQuery) WhereGroup 

func (q *UpdateQuery) WhereGroup(sep string, fn func(*WhereQuery)) *UpdateQuery

func (*UpdateQuery) WhereOr 

func (q *UpdateQuery) WhereOr(query string, args ...interface{}) *UpdateQuery

func (*UpdateQuery) WherePK 

func (q *UpdateQuery) WherePK() *UpdateQuery

WherePK adds conditions based on the model primary keys. Usually it is the same as: 

Where("id = ?id")

func (*UpdateQuery) With 

func (q *UpdateQuery) With(name string, query schema.QueryAppender) *UpdateQuery

type ValuesQuery 

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

func NewValuesQuery 

func NewValuesQuery(db *DB, model interface{}) *ValuesQuery

func (*ValuesQuery) AppendArg 

func (q *ValuesQuery) AppendArg(fmter schema.Formatter, b []byte, name string) ([]byte, bool)

func (*ValuesQuery) AppendColumns 

func (q *ValuesQuery) AppendColumns(fmter schema.Formatter, b []byte) (_ []byte, err error)

AppendColumns appends the table columns. It is used by CTE.

func (*ValuesQuery) AppendQuery 

func (q *ValuesQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error)

func (*ValuesQuery) DB 

func (q *ValuesQuery) DB(db DBI) *ValuesQuery

func (*ValuesQuery) GetDB 

func (q *ValuesQuery) GetDB() *DB

func (*ValuesQuery) WithOrder 

func (q *ValuesQuery) WithOrder() *ValuesQuery

type WhereQuery 

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

func (*WhereQuery) Where 

func (q *WhereQuery) Where(query string, args ...interface{}) *WhereQuery

func (*WhereQuery) WhereGroup 

func (q *WhereQuery) WhereGroup(sep string, fn func(*WhereQuery))

func (*WhereQuery) WhereOr 

func (q *WhereQuery) WhereOr(query string, args ...interface{}) *WhereQuery

Source Files

View all Source files

Directories

Path Synopsis
dbfixture module
feature
sqltype
mssqldialect Module
mysqldialect Module
pgdialect Module
sqlitedialect Module
driver
pgdriver Module
sqliteshim Module
example
basic Module
belongs-to Module
create-table-index Module
cursor-pagination Module
custom-type Module
fixture Module
get-where-fields Module
has-many Module
has-one Module
migrate Module
model-hooks Module
multi-tenant Module
opentelemetry Module
pg-faceted-search Module
pg-listen Module
placeholders Module
rel-belongs-to Module
rel-has-many Module
rel-has-many-polymorphic Module
rel-has-one Module
rel-join-condition Module
rel-many-to-many Module
rel-many-to-many-self Module
string-representation Module
trivial Module
tx-composition Module
extra
bunbig Module
bundebug Module
bunotel Module
bunrelic Module
bunslog Module
fixture module
parser
tagparser
dbtest Module
testfixture module

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.