dbr: github.com/gocraft/dbr Index | Examples | Files | Directories

package dbr

import "github.com/gocraft/dbr"

Package dbr provides additions to Go's database/sql for super fast performance and convenience.

Index

Examples

Package Files

buffer.go builder.go comments.go condition.go dbr.go delete.go dialect.go errors.go event.go expr.go ident.go insert.go interpolate.go join.go load.go now.go order.go select.go select_return.go transaction.go types.go union.go update.go util.go

Variables

var (
    ErrNotFound           = errors.New("dbr: not found")
    ErrNotSupported       = errors.New("dbr: not supported")
    ErrTableNotSpecified  = errors.New("dbr: table not specified")
    ErrColumnNotSpecified = errors.New("dbr: column not specified")
    ErrInvalidPointer     = errors.New("dbr: attempt to load into an invalid pointer")
    ErrPlaceholderCount   = errors.New("dbr: wrong placeholder count")
    ErrInvalidSliceLength = errors.New("dbr: length of slice is 0. length must be >= 1")
    ErrCantConvertToTime  = errors.New("dbr: can't convert to time.Time")
    ErrInvalidTimestring  = errors.New("dbr: invalid time string")
)

package errors

var NameMapping = camelCaseToSnakeCase
var Now = nowSentinel{}

Now is a value that serializes to the current time in UTC.

func InterfaceLoader Uses

func InterfaceLoader(value interface{}, concreteType interface{}) interface{}

func InterpolateForDialect Uses

func InterpolateForDialect(query string, value []interface{}, d Dialect) (string, error)

InterpolateForDialect replaces placeholder in query with corresponding value in dialect.

It can be also used for debugging custom Builder.

Every time you call database/sql's db.Query("SELECT ...") method, under the hood, the mysql driver will create a prepared statement, execute it, and then throw it away. This has a big performance cost.

gocraft/dbr doesn't use prepared statements. We ported mysql's query escape functionality directly into our package, which means we interpolate all of those question marks with their arguments before they get to MySQL. The result of this is that it's way faster, and just as secure.

Check out these benchmarks from https://github.com/tyler-smith/golang-sql-benchmark.

func Load Uses

func Load(rows *sql.Rows, value interface{}) (int, error)

Load loads any value from sql.Rows.

value can be:

1. simple type like int64, string, etc.

2. sql.Scanner, which allows loading with custom types.

3. map; the first column from SQL result loaded to the key, and the rest of columns will be loaded into the value. This is useful to dedup SQL result with first column.

4. map of slice; like map, values with the same key are collected with a slice.

func Union Uses

func Union(builder ...Builder) interface {
    Builder
    As(string) Builder
}

Union builds `... UNION ...`.

Code:

Union(
    Select("*"),
    Select("*"),
).As("subquery")

func UnionAll Uses

func UnionAll(builder ...Builder) interface {
    Builder
    As(string) Builder
}

UnionAll builds `... UNION ALL ...`.

Code:

UnionAll(
    Select("*"),
    Select("*"),
).As("subquery")

type Buffer Uses

type Buffer interface {
    WriteString(string) (int, error)
    String() string

    WriteValue(v ...interface{}) (err error)
    Value() []interface{}
}

Buffer collects strings, and values that are ready to be interpolated. This is used internally to efficiently build SQL statement.

func NewBuffer Uses

func NewBuffer() Buffer

NewBuffer creates a new Buffer.

type BuildFunc Uses

type BuildFunc func(Dialect, Buffer) error

BuildFunc implements Builder.

func (BuildFunc) Build Uses

func (b BuildFunc) Build(d Dialect, buf Buffer) error

Build calls itself to build SQL.

type Builder Uses

type Builder interface {
    Build(Dialect, Buffer) error
}

Builder builds SQL in Dialect like MySQL, and PostgreSQL. The raw SQL and values are stored in Buffer.

The core of gocraft/dbr is interpolation, which can expand ? with arbitrary SQL. If you need a feature that is not currently supported, you can build it on your own (or use Expr).

To do that, the value that you wish to be expanded with ? needs to implement Builder.

func And Uses

func And(cond ...Builder) Builder

And creates AND from a list of conditions.

Code:

And(
    Or(
        Gt("created_at", "2015-09-10"),
        Lte("created_at", "2015-09-11"),
    ),
    Eq("title", "hello world"),
)

func Eq Uses

func Eq(column string, value interface{}) Builder

Eq is `=`. When value is nil, it will be translated to `IS NULL`. When value is a slice, it will be translated to `IN`. Otherwise it will be translated to `=`.

func Expr Uses

func Expr(query string, value ...interface{}) Builder

Expr allows raw expression to be used when current SQL syntax is not supported by gocraft/dbr.

func Gt Uses

func Gt(column string, value interface{}) Builder

Gt is `>`.

func Gte Uses

func Gte(column string, value interface{}) Builder

Gte is '>='.

func Like Uses

func Like(column, value string, escape ...string) Builder

Like is `LIKE`, with an optional `ESCAPE` clause

func Lt Uses

func Lt(column string, value interface{}) Builder

Lt is '<'.

func Lte Uses

func Lte(column string, value interface{}) Builder

Lte is `<=`.

func Neq Uses

func Neq(column string, value interface{}) Builder

Neq is `!=`. When value is nil, it will be translated to `IS NOT NULL`. When value is a slice, it will be translated to `NOT IN`. Otherwise it will be translated to `!=`.

func NotLike Uses

func NotLike(column, value string, escape ...string) Builder

NotLike is `NOT LIKE`, with an optional `ESCAPE` clause

func Or Uses

func Or(cond ...Builder) Builder

Or creates OR from a list of conditions.

type Comments Uses

type Comments []string

Comments represents a set of sql comments

func (Comments) Append Uses

func (comments Comments) Append(comment string) Comments

Append a new sql comment to a set of comments

func (Comments) Build Uses

func (comments Comments) Build(d Dialect, buf Buffer) error

Build writes each comment in the form of "/* some comment */\n"

type Connection Uses

type Connection struct {
    *sql.DB
    Dialect
    EventReceiver
}

Connection wraps sql.DB with an EventReceiver to send events, errors, and timings.

func Open Uses

func Open(driver, dsn string, log EventReceiver) (*Connection, error)

Open creates a Connection. log can be nil to ignore logging.

Code:

// create a connection (e.g. "postgres", "mysql", or "sqlite3")
conn, _ := Open("postgres", "...", nil)
conn.SetMaxOpenConns(10)

// create a session for each business unit of execution (e.g. a web request or goworkers job)
sess := conn.NewSession(nil)

// create a tx from sessions
sess.Begin()

func (*Connection) NewSession Uses

func (conn *Connection) NewSession(log EventReceiver) *Session

NewSession instantiates a Session from Connection. If log is nil, Connection EventReceiver is used.

type DeleteBuilder Uses

type DeleteBuilder = DeleteStmt

type DeleteStmt Uses

type DeleteStmt struct {
    EventReceiver
    Dialect

    Table      string
    WhereCond  []Builder
    LimitCount int64
    // contains filtered or unexported fields
}

DeleteStmt builds `DELETE ...`.

Code:

sess := mysqlSession
sess.DeleteFrom("suggestions").
    Where("id = ?", 1)

func DeleteBySql Uses

func DeleteBySql(query string, value ...interface{}) *DeleteStmt

DeleteBySql creates a DeleteStmt from raw query.

func DeleteFrom Uses

func DeleteFrom(table string) *DeleteStmt

DeleteFrom creates a DeleteStmt.

func (*DeleteStmt) Build Uses

func (b *DeleteStmt) Build(d Dialect, buf Buffer) error

func (*DeleteStmt) Comment Uses

func (b *DeleteStmt) Comment(comment string) *DeleteStmt

func (*DeleteStmt) Exec Uses

func (b *DeleteStmt) Exec() (sql.Result, error)

func (*DeleteStmt) ExecContext Uses

func (b *DeleteStmt) ExecContext(ctx context.Context) (sql.Result, error)

func (*DeleteStmt) Limit Uses

func (b *DeleteStmt) Limit(n uint64) *DeleteStmt

func (*DeleteStmt) Where Uses

func (b *DeleteStmt) Where(query interface{}, value ...interface{}) *DeleteStmt

Where adds a where condition. query can be Builder or string. value is used only if query type is string.

type Dialect Uses

type Dialect interface {
    QuoteIdent(id string) string

    EncodeString(s string) string
    EncodeBool(b bool) string
    EncodeTime(t time.Time) string
    EncodeBytes(b []byte) string

    Placeholder(n int) string
}

Dialect abstracts database driver differences in encoding types, and placeholders.

type EventReceiver Uses

type EventReceiver interface {
    Event(eventName string)
    EventKv(eventName string, kvs map[string]string)
    EventErr(eventName string, err error) error
    EventErrKv(eventName string, err error, kvs map[string]string) error
    Timing(eventName string, nanoseconds int64)
    TimingKv(eventName string, nanoseconds int64, kvs map[string]string)
}

EventReceiver gets events from dbr methods for logging purposes.

type I Uses

type I string

I is quoted identifier

Code:

// I, identifier, can be used to quote.
I("suggestions.id").As("id") // `suggestions`.`id`

func (I) As Uses

func (i I) As(alias string) Builder

As creates an alias for expr.

func (I) Build Uses

func (i I) Build(d Dialect, buf Buffer) error

Build quotes string with dialect.

type InsertBuilder Uses

type InsertBuilder = InsertStmt

type InsertStmt Uses

type InsertStmt struct {
    EventReceiver
    Dialect

    Table        string
    Column       []string
    Value        [][]interface{}
    Ignored      bool
    ReturnColumn []string
    RecordID     *int64
    // contains filtered or unexported fields
}

InsertStmt builds `INSERT INTO ...`.

func InsertBySql Uses

func InsertBySql(query string, value ...interface{}) *InsertStmt

InsertBySql creates an InsertStmt from raw query.

func InsertInto Uses

func InsertInto(table string) *InsertStmt

InsertInto creates an InsertStmt.

func (*InsertStmt) Build Uses

func (b *InsertStmt) Build(d Dialect, buf Buffer) error

func (*InsertStmt) Columns Uses

func (b *InsertStmt) Columns(column ...string) *InsertStmt

func (*InsertStmt) Comment Uses

func (b *InsertStmt) Comment(comment string) *InsertStmt

Comment adds a comment to prepended. All multi-line sql comment characters are stripped

func (*InsertStmt) Exec Uses

func (b *InsertStmt) Exec() (sql.Result, error)

func (*InsertStmt) ExecContext Uses

func (b *InsertStmt) ExecContext(ctx context.Context) (sql.Result, error)

func (*InsertStmt) Ignore Uses

func (b *InsertStmt) Ignore() *InsertStmt

Ignore any insertion errors

func (*InsertStmt) Load Uses

func (b *InsertStmt) Load(value interface{}) error

func (*InsertStmt) LoadContext Uses

func (b *InsertStmt) LoadContext(ctx context.Context, value interface{}) error

func (*InsertStmt) Pair Uses

func (b *InsertStmt) Pair(column string, value interface{}) *InsertStmt

Pair adds (column, value) to be inserted. It is an error to mix Pair with Values and Record.

Code:

sess := mysqlSession
sess.InsertInto("suggestions").
    Pair("title", "Gopher").
    Pair("body", "I love go.")

func (*InsertStmt) Record Uses

func (b *InsertStmt) Record(structValue interface{}) *InsertStmt

Record adds a tuple for columns from a struct.

If there is a field called "Id" or "ID" in the struct, it will be set to LastInsertId.

Code:

type Suggestion struct {
    ID        int64
    Title     NullString
    CreatedAt time.Time
}
sugg := &Suggestion{
    Title:     NewNullString("Gopher"),
    CreatedAt: time.Now(),
}
sess := mysqlSession
sess.InsertInto("suggestions").
    Columns("title").
    Record(&sugg).
    Exec()

// id is set automatically
fmt.Println(sugg.ID)

func (*InsertStmt) Returning Uses

func (b *InsertStmt) Returning(column ...string) *InsertStmt

Returning specifies the returning columns for postgres.

func (*InsertStmt) Values Uses

func (b *InsertStmt) Values(value ...interface{}) *InsertStmt

Values adds a tuple to be inserted. The order of the tuple should match Columns.

type NullBool Uses

type NullBool struct {
    sql.NullBool
}

NullBool is a type that can be null or a bool.

func NewNullBool Uses

func NewNullBool(v interface{}) (n NullBool)

NewNullBool creates a NullBool with Scan().

func (NullBool) MarshalJSON Uses

func (n NullBool) MarshalJSON() ([]byte, error)

MarshalJSON correctly serializes a NullBool to JSON.

func (*NullBool) UnmarshalJSON Uses

func (n *NullBool) UnmarshalJSON(b []byte) error

UnmarshalJSON correctly deserializes a NullBool from JSON.

type NullEventReceiver Uses

type NullEventReceiver struct{}

NullEventReceiver is a sentinel EventReceiver. Use it if the caller doesn't supply one.

func (*NullEventReceiver) Event Uses

func (n *NullEventReceiver) Event(eventName string)

Event receives a simple notification when various events occur.

func (*NullEventReceiver) EventErr Uses

func (n *NullEventReceiver) EventErr(eventName string, err error) error

EventErr receives a notification of an error if one occurs.

func (*NullEventReceiver) EventErrKv Uses

func (n *NullEventReceiver) EventErrKv(eventName string, err error, kvs map[string]string) error

EventErrKv receives a notification of an error if one occurs along with optional key/value data.

func (*NullEventReceiver) EventKv Uses

func (n *NullEventReceiver) EventKv(eventName string, kvs map[string]string)

EventKv receives a notification when various events occur along with optional key/value data.

func (*NullEventReceiver) Timing Uses

func (n *NullEventReceiver) Timing(eventName string, nanoseconds int64)

Timing receives the time an event took to happen.

func (*NullEventReceiver) TimingKv Uses

func (n *NullEventReceiver) TimingKv(eventName string, nanoseconds int64, kvs map[string]string)

TimingKv receives the time an event took to happen along with optional key/value data.

type NullFloat64 Uses

type NullFloat64 struct {
    sql.NullFloat64
}

NullFloat64 is a type that can be null or a float64.

func NewNullFloat64 Uses

func NewNullFloat64(v interface{}) (n NullFloat64)

NewNullFloat64 creates a NullFloat64 with Scan().

func (NullFloat64) MarshalJSON Uses

func (n NullFloat64) MarshalJSON() ([]byte, error)

MarshalJSON correctly serializes a NullFloat64 to JSON.

func (*NullFloat64) UnmarshalJSON Uses

func (n *NullFloat64) UnmarshalJSON(b []byte) error

UnmarshalJSON correctly deserializes a NullFloat64 from JSON.

type NullInt64 Uses

type NullInt64 struct {
    sql.NullInt64
}

NullInt64 is a type that can be null or an int.

func NewNullInt64 Uses

func NewNullInt64(v interface{}) (n NullInt64)

NewNullInt64 creates a NullInt64 with Scan().

func (NullInt64) MarshalJSON Uses

func (n NullInt64) MarshalJSON() ([]byte, error)

MarshalJSON correctly serializes a NullInt64 to JSON.

func (*NullInt64) UnmarshalJSON Uses

func (n *NullInt64) UnmarshalJSON(b []byte) error

UnmarshalJSON correctly deserializes a NullInt64 from JSON.

type NullString Uses

type NullString struct {
    sql.NullString
}

NullString is a type that can be null or a string.

func NewNullString Uses

func NewNullString(v interface{}) (n NullString)

NewNullString creates a NullString with Scan().

func (NullString) MarshalJSON Uses

func (n NullString) MarshalJSON() ([]byte, error)

MarshalJSON correctly serializes a NullString to JSON.

func (*NullString) UnmarshalJSON Uses

func (n *NullString) UnmarshalJSON(b []byte) error

UnmarshalJSON correctly deserializes a NullString from JSON.

type NullTime Uses

type NullTime struct {
    Time  time.Time
    Valid bool // Valid is true if Time is not NULL
}

NullTime is a type that can be null or a time.

func NewNullTime Uses

func NewNullTime(v interface{}) (n NullTime)

NewNullTime creates a NullTime with Scan().

func (NullTime) MarshalJSON Uses

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

MarshalJSON correctly serializes a NullTime to JSON.

func (*NullTime) Scan Uses

func (n *NullTime) Scan(value interface{}) error

Scan implements the Scanner interface. The value type must be time.Time or string / []byte (formatted time-string), otherwise Scan fails.

func (*NullTime) UnmarshalJSON Uses

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

UnmarshalJSON correctly deserializes a NullTime from JSON.

func (NullTime) Value Uses

func (n NullTime) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type SelectBuilder Uses

type SelectBuilder = SelectStmt

type SelectStmt Uses

type SelectStmt struct {
    EventReceiver
    Dialect

    IsDistinct bool

    Column    []interface{}
    Table     interface{}
    JoinTable []Builder

    WhereCond  []Builder
    Group      []Builder
    HavingCond []Builder
    Order      []Builder
    Suffixes   []Builder

    LimitCount  int64
    OffsetCount int64
    // contains filtered or unexported fields
}

SelectStmt builds `SELECT ...`.

func Select Uses

func Select(column ...interface{}) *SelectStmt

Select creates a SelectStmt.

Code:

Select("title", "body").
    From("suggestions").
    OrderBy("id").
    Limit(10)

func SelectBySql Uses

func SelectBySql(query string, value ...interface{}) *SelectStmt

SelectBySql creates a SelectStmt from raw query.

Code:

SelectBySql("SELECT `title`, `body` FROM `suggestions` ORDER BY `id` ASC LIMIT 10")

func (*SelectStmt) As Uses

func (b *SelectStmt) As(alias string) Builder

As creates alias for select statement.

Code:

sess := mysqlSession
sess.Select("count(id)").From(
    Select("*").From("suggestions").As("count"),
)

func (*SelectStmt) Build Uses

func (b *SelectStmt) Build(d Dialect, buf Buffer) error

func (*SelectStmt) Comment Uses

func (b *SelectStmt) Comment(comment string) *SelectStmt

func (*SelectStmt) Distinct Uses

func (b *SelectStmt) Distinct() *SelectStmt

func (*SelectStmt) From Uses

func (b *SelectStmt) From(table interface{}) *SelectStmt

From specifies table to select from. table can be Builder like SelectStmt, or string.

func (*SelectStmt) FullJoin Uses

func (b *SelectStmt) FullJoin(table, on interface{}) *SelectStmt

FullJoin add full-join. on can be Builder or string.

func (*SelectStmt) GroupBy Uses

func (b *SelectStmt) GroupBy(col ...string) *SelectStmt

GroupBy specifies columns for grouping.

func (*SelectStmt) Having Uses

func (b *SelectStmt) Having(query interface{}, value ...interface{}) *SelectStmt

Having adds a having condition. query can be Builder or string. value is used only if query type is string.

func (*SelectStmt) Join Uses

func (b *SelectStmt) Join(table, on interface{}) *SelectStmt

Join add inner-join. on can be Builder or string.

Code:

sess := mysqlSession
sess.Select("*").From("suggestions").
    Join("subdomains", "suggestions.subdomain_id = subdomains.id")

sess.Select("*").From("suggestions").
    LeftJoin("subdomains", "suggestions.subdomain_id = subdomains.id")

// join multiple tables
sess.Select("*").From("suggestions").
    Join("subdomains", "suggestions.subdomain_id = subdomains.id").
    Join("accounts", "subdomains.accounts_id = accounts.id")

func (*SelectStmt) LeftJoin Uses

func (b *SelectStmt) LeftJoin(table, on interface{}) *SelectStmt

LeftJoin add left-join. on can be Builder or string.

func (*SelectStmt) Limit Uses

func (b *SelectStmt) Limit(n uint64) *SelectStmt

func (*SelectStmt) Load Uses

func (b *SelectStmt) Load(value interface{}) (int, error)

Load loads multi-row SQL result into a slice of go variables.

See https://godoc.org/github.com/gocraft/dbr#Load.

Code:

// columns are mapped by tag then by field
type Suggestion struct {
    ID     int64      // id, will be autoloaded by last insert id
    Title  NullString `db:"subject"` // subjects are called titles now
    Url    string     `db:"-"`       // ignored
    secret string     // ignored
}

// By default gocraft/dbr converts CamelCase property names to snake_case column_names.
// You can override this with struct tags, just like with JSON tags.
// This is especially helpful while migrating from legacy systems.
var suggestions []Suggestion
sess := mysqlSession
sess.Select("*").From("suggestions").Load(&suggestions)

func (*SelectStmt) LoadContext Uses

func (b *SelectStmt) LoadContext(ctx context.Context, value interface{}) (int, error)

func (*SelectStmt) LoadOne Uses

func (b *SelectStmt) LoadOne(value interface{}) error

LoadOne loads SQL result into go variable that is not a slice. Unlike Load, it returns ErrNotFound if the SQL result row count is 0.

See https://godoc.org/github.com/gocraft/dbr#Load.

func (*SelectStmt) LoadOneContext Uses

func (b *SelectStmt) LoadOneContext(ctx context.Context, value interface{}) error

func (*SelectStmt) Offset Uses

func (b *SelectStmt) Offset(n uint64) *SelectStmt

func (*SelectStmt) OrderAsc Uses

func (b *SelectStmt) OrderAsc(col string) *SelectStmt

func (*SelectStmt) OrderBy Uses

func (b *SelectStmt) OrderBy(col string) *SelectStmt

OrderBy specifies columns for ordering.

func (*SelectStmt) OrderDesc Uses

func (b *SelectStmt) OrderDesc(col string) *SelectStmt

func (*SelectStmt) OrderDir Uses

func (b *SelectStmt) OrderDir(col string, isAsc bool) *SelectStmt

OrderDir is a helper for OrderAsc and OrderDesc.

func (*SelectStmt) Paginate Uses

func (b *SelectStmt) Paginate(page, perPage uint64) *SelectStmt

Paginate fetches a page in a naive way for a small set of data.

func (*SelectStmt) ReturnInt64 Uses

func (b *SelectStmt) ReturnInt64() (int64, error)

ReturnInt64 executes the SelectStmt and returns the value as an int64.

func (*SelectStmt) ReturnInt64s Uses

func (b *SelectStmt) ReturnInt64s() ([]int64, error)

ReturnInt64s executes the SelectStmt and returns the value as a slice of int64s.

func (*SelectStmt) ReturnString Uses

func (b *SelectStmt) ReturnString() (string, error)

ReturnString executes the SelectStmt and returns the value as a string.

func (*SelectStmt) ReturnStrings Uses

func (b *SelectStmt) ReturnStrings() ([]string, error)

ReturnStrings executes the SelectStmt and returns the value as a slice of strings.

func (*SelectStmt) ReturnUint64 Uses

func (b *SelectStmt) ReturnUint64() (uint64, error)

ReturnUint64 executes the SelectStmt and returns the value as an uint64.

func (*SelectStmt) ReturnUint64s Uses

func (b *SelectStmt) ReturnUint64s() ([]uint64, error)

ReturnUint64s executes the SelectStmt and returns the value as a slice of uint64s.

func (*SelectStmt) RightJoin Uses

func (b *SelectStmt) RightJoin(table, on interface{}) *SelectStmt

RightJoin add right-join. on can be Builder or string.

func (*SelectStmt) Rows Uses

func (b *SelectStmt) Rows() (*sql.Rows, error)

Rows executes the query and returns the rows returned, or any error encountered.

func (*SelectStmt) RowsContext Uses

func (b *SelectStmt) RowsContext(ctx context.Context) (*sql.Rows, error)

func (*SelectStmt) Suffix Uses

func (b *SelectStmt) Suffix(suffix string, value ...interface{}) *SelectStmt

Suffix adds an expression to the end of the query. This is useful to add dialect-specific clauses like FOR UPDATE

func (*SelectStmt) Where Uses

func (b *SelectStmt) Where(query interface{}, value ...interface{}) *SelectStmt

Where adds a where condition. query can be Builder or string. value is used only if query type is string.

Code:

// database/sql uses prepared statements, which means each argument
// in an IN clause needs its own question mark.
// gocraft/dbr, on the other hand, handles interpolation itself
// so that you can easily use a single question mark paired with a
// dynamically sized slice.

sess := mysqlSession
ids := []int64{1, 2, 3, 4, 5}
sess.Select("*").From("suggestions").Where("id IN ?", ids)

type Session Uses

type Session struct {
    *Connection
    EventReceiver
    Timeout time.Duration
}

Session represents a business unit of execution.

All queries in gocraft/dbr are made in the context of a session. This is because when instrumenting your app, it's important to understand which business action the query took place in.

A custom EventReceiver can be set.

Timeout specifies max duration for an operation like Select.

func (*Session) Begin Uses

func (sess *Session) Begin() (*Tx, error)

Begin creates a transaction for the given session.

func (*Session) BeginTx Uses

func (sess *Session) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error)

BeginTx creates a transaction with TxOptions.

func (*Session) DeleteBySql Uses

func (sess *Session) DeleteBySql(query string, value ...interface{}) *DeleteStmt

DeleteBySql creates a DeleteStmt from raw query.

func (*Session) DeleteFrom Uses

func (sess *Session) DeleteFrom(table string) *DeleteStmt

DeleteFrom creates a DeleteStmt.

func (*Session) GetTimeout Uses

func (sess *Session) GetTimeout() time.Duration

GetTimeout returns current timeout enforced in session.

func (*Session) InsertBySql Uses

func (sess *Session) InsertBySql(query string, value ...interface{}) *InsertStmt

InsertBySql creates an InsertStmt from raw query.

func (*Session) InsertInto Uses

func (sess *Session) InsertInto(table string) *InsertStmt

InsertInto creates an InsertStmt.

func (*Session) Select Uses

func (sess *Session) Select(column ...string) *SelectStmt

Select creates a SelectStmt.

func (*Session) SelectBySql Uses

func (sess *Session) SelectBySql(query string, value ...interface{}) *SelectStmt

SelectBySql creates a SelectStmt from raw query.

func (*Session) Update Uses

func (sess *Session) Update(table string) *UpdateStmt

Update creates an UpdateStmt.

func (*Session) UpdateBySql Uses

func (sess *Session) UpdateBySql(query string, value ...interface{}) *UpdateStmt

UpdateBySql creates an UpdateStmt with raw query.

type SessionRunner Uses

type SessionRunner interface {
    Select(column ...string) *SelectBuilder
    SelectBySql(query string, value ...interface{}) *SelectBuilder

    InsertInto(table string) *InsertBuilder
    InsertBySql(query string, value ...interface{}) *InsertBuilder

    Update(table string) *UpdateBuilder
    UpdateBySql(query string, value ...interface{}) *UpdateBuilder

    DeleteFrom(table string) *DeleteBuilder
    DeleteBySql(query string, value ...interface{}) *DeleteBuilder
}

SessionRunner can do anything that a Session can except start a transaction. Both Session and Tx implements this interface.

type TracingEventReceiver Uses

type TracingEventReceiver interface {
    SpanStart(ctx context.Context, eventName, query string) context.Context
    SpanError(ctx context.Context, err error)
    SpanFinish(ctx context.Context)
}

TracingEventReceiver is an optional interface an EventReceiver type can implement to allow tracing instrumentation

type Tx Uses

type Tx struct {
    EventReceiver
    Dialect
    *sql.Tx
    Timeout time.Duration
}

Tx is a transaction created by Session.

Code:

sess := mysqlSession
tx, err := sess.Begin()
if err != nil {
    return
}
defer tx.RollbackUnlessCommitted()

// do stuff...

tx.Commit()

func (*Tx) Commit Uses

func (tx *Tx) Commit() error

Commit finishes the transaction.

func (*Tx) DeleteBySql Uses

func (tx *Tx) DeleteBySql(query string, value ...interface{}) *DeleteStmt

DeleteBySql creates a DeleteStmt from raw query.

func (*Tx) DeleteFrom Uses

func (tx *Tx) DeleteFrom(table string) *DeleteStmt

DeleteFrom creates a DeleteStmt.

func (*Tx) GetTimeout Uses

func (tx *Tx) GetTimeout() time.Duration

GetTimeout returns timeout enforced in Tx.

func (*Tx) InsertBySql Uses

func (tx *Tx) InsertBySql(query string, value ...interface{}) *InsertStmt

InsertBySql creates an InsertStmt from raw query.

func (*Tx) InsertInto Uses

func (tx *Tx) InsertInto(table string) *InsertStmt

InsertInto creates an InsertStmt.

func (*Tx) Rollback Uses

func (tx *Tx) Rollback() error

Rollback cancels the transaction.

func (*Tx) RollbackUnlessCommitted Uses

func (tx *Tx) RollbackUnlessCommitted()

RollbackUnlessCommitted rollsback the transaction unless it has already been committed or rolled back.

Useful to defer tx.RollbackUnlessCommitted(), so you don't have to handle N failure cases. Keep in mind the only way to detect an error on the rollback is via the event log.

func (*Tx) Select Uses

func (tx *Tx) Select(column ...string) *SelectStmt

Select creates a SelectStmt.

func (*Tx) SelectBySql Uses

func (tx *Tx) SelectBySql(query string, value ...interface{}) *SelectStmt

SelectBySql creates a SelectStmt from raw query.

func (*Tx) Update Uses

func (tx *Tx) Update(table string) *UpdateStmt

Update creates an UpdateStmt.

func (*Tx) UpdateBySql Uses

func (tx *Tx) UpdateBySql(query string, value ...interface{}) *UpdateStmt

UpdateBySql creates an UpdateStmt with raw query.

type UpdateBuilder Uses

type UpdateBuilder = UpdateStmt

type UpdateStmt Uses

type UpdateStmt struct {
    EventReceiver
    Dialect

    Table        string
    Value        map[string]interface{}
    WhereCond    []Builder
    ReturnColumn []string
    LimitCount   int64
    // contains filtered or unexported fields
}

UpdateStmt builds `UPDATE ...`.

Code:

sess := mysqlSession
sess.Update("suggestions").
    Set("title", "Gopher").
    Set("body", "I love go.").
    Where("id = ?", 1)

func Update Uses

func Update(table string) *UpdateStmt

Update creates an UpdateStmt.

func UpdateBySql Uses

func UpdateBySql(query string, value ...interface{}) *UpdateStmt

UpdateBySql creates an UpdateStmt with raw query.

func (*UpdateStmt) Build Uses

func (b *UpdateStmt) Build(d Dialect, buf Buffer) error

func (*UpdateStmt) Comment Uses

func (b *UpdateStmt) Comment(comment string) *UpdateStmt

func (*UpdateStmt) DecrBy Uses

func (b *UpdateStmt) DecrBy(column string, value interface{}) *UpdateStmt

DecrBy decreases column by value

func (*UpdateStmt) Exec Uses

func (b *UpdateStmt) Exec() (sql.Result, error)

func (*UpdateStmt) ExecContext Uses

func (b *UpdateStmt) ExecContext(ctx context.Context) (sql.Result, error)

func (*UpdateStmt) IncrBy Uses

func (b *UpdateStmt) IncrBy(column string, value interface{}) *UpdateStmt

IncrBy increases column by value

func (*UpdateStmt) Limit Uses

func (b *UpdateStmt) Limit(n uint64) *UpdateStmt

func (*UpdateStmt) Load Uses

func (b *UpdateStmt) Load(value interface{}) error

func (*UpdateStmt) LoadContext Uses

func (b *UpdateStmt) LoadContext(ctx context.Context, value interface{}) error

func (*UpdateStmt) Returning Uses

func (b *UpdateStmt) Returning(column ...string) *UpdateStmt

Returning specifies the returning columns for postgres.

func (*UpdateStmt) Set Uses

func (b *UpdateStmt) Set(column string, value interface{}) *UpdateStmt

Set updates column with value.

func (*UpdateStmt) SetMap Uses

func (b *UpdateStmt) SetMap(m map[string]interface{}) *UpdateStmt

SetMap specifies a map of (column, value) to update in bulk.

func (*UpdateStmt) Where Uses

func (b *UpdateStmt) Where(query interface{}, value ...interface{}) *UpdateStmt

Where adds a where condition. query can be Builder or string. value is used only if query type is string.

Directories

PathSynopsis
dialect
opentracing

Package dbr imports 12 packages (graph) and is imported by 69 packages. Updated 2020-02-18. Refresh now. Tools for package owners.