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: 1,118

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 (*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 (*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 (*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 (*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

Directories

Path Synopsis
dbfixture module
mssqldialect Module
mysqldialect Module
pgdialect Module
sqlitedialect Module
driver
pgdriver Module
sqliteshim Module
example
basic Module
belongs-to Module
custom-type Module
fixture Module
has-many Module
has-one Module
migrate Module
model-hooks Module
multi-tenant Module
opentelemetry Module
pg-listen Module
placeholders Module
rel-has-many Module
rel-has-one Module
trivial Module
extra
bunbig Module
bundebug Module
bunotel Module
bunrelic Module
bunslog Module
fixture module
dbtest Module
testfixture module

Jump to

Keyboard shortcuts

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