dbr

package module
v3.2.1+incompatible Latest Latest
Warning

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

Go to latest
Published: Feb 8, 2022 License: MIT Imports: 13 Imported by: 0

README

mbict/dbr (database records) GoDoc

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

Getting Started

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

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

// get a record
var suggestion Suggestion
sess.Select("id", "title").From("suggestions").Where("id = ?", 1).LoadOne(&suggestion)

// JSON-ready, with dbr.Null* types serialized like you want
json.Marshal(&suggestion)

Feature highlights

Use a Sweet Query Builder or use Plain SQL

mbict/dbr supports both.

Sweet Query Builder:

stmt := dbr.Select("title", "body").
	From("suggestions").
	OrderBy("id").
	Limit(10)

Plain SQL:

builder := dbr.SelectBySql("SELECT `title`, `body` FROM `suggestions` ORDER BY `id` ASC LIMIT 10")
Amazing instrumentation with session

All queries in mbict/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. See gocraft/health for more detail.

Writing instrumented code is a first-class concern for mbict/dbr. We instrument each query to emit to a gocraft/health-compatible EventReceiver interface.

Faster performance than using database/sql directly

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.

mbict/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.

IN queries that aren't horrible

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

ids := []int64{1, 2, 3, 4, 5}
builder.Where("id IN ?", ids) // `id` IN ?
JSON Friendly

Every try to JSON-encode a sql.NullString? You get:

{
	"str1": {
		"Valid": true,
		"String": "Hi!"
	},
	"str2": {
		"Valid": false,
		"String": ""
  }
}

Not quite what you want. mbict/dbr has dbr.NullString (and the rest of the Null* types) that encode correctly, giving you:

{
	"str1": "Hi!",
	"str2": null
}
Inserting multiple records
sess.InsertInto("suggestions").Columns("title", "body").
  Record(suggestion1).
  Record(suggestion2)
Updating records
sess.Update("suggestions").
	Set("title", "Gopher").
	Set("body", "I love go.").
	Where("id = ?", 1)
Transactions
tx, err := sess.Begin()
if err != nil {
  return err
}
defer tx.RollbackUnlessCommitted()

// do stuff...

return tx.Commit()
Load database values to variables

Querying is the heart of mbict/dbr.

  • Load(&any): load everything!
  • LoadOne(&one): load one struct or value
// columns are mapped by tag then by field
type Suggestion struct {
	ID int64  // id, will be autoloaded by last insert id
	Title string // title
	Url string `db:"-"` // ignored
	secret string // ignored
	Body dbr.NullString `db:"content"` // content
	User User
}

// By default 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
type Suggestion struct {
	Id        int64
	Title     dbr.NullString `db:"subject"` // subjects are called titles now
	CreatedAt dbr.NullTime
}

var suggestions []Suggestion
sess.Select("*").From("suggestions").Load(&suggestions)
Join multiple tables

dbr supports many join types:

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

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

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

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

You can join on multiple tables:

sess.Select("*").From("suggestions").
  Join("subdomains", "suggestions.subdomain_id = subdomains.id").
  Join("accounts", "subdomains.accounts_id = accounts.id")
Quoting/escaping identifiers (e.g. table and column names)
dbr.I("suggestions.id") // `suggestions`.`id`
Subquery
sess.Select("count(id)").From(
  dbr.Select("*").From("suggestions").As("count"),
)
Union
dbr.Union(
  dbr.Select("*"),
  dbr.Select("*"),
)

dbr.UnionAll(
  dbr.Select("*"),
  dbr.Select("*"),
)

Union can be used in subquery.

Alias/AS
  • SelectStmt
dbr.Select("*").From("suggestions").As("count")
  • Identity
dbr.I("suggestions").As("s")
  • Union
dbr.Union(
  dbr.Select("*"),
  dbr.Select("*"),
).As("u1")

dbr.UnionAll(
  dbr.Select("*"),
  dbr.Select("*"),
).As("u2")
Building arbitrary condition

One common reason to use this is to prevent string concatenation in a loop.

  • And
  • Or
  • Eq
  • Neq
  • Gt
  • Gte
  • Lt
  • Lte
dbr.And(
  dbr.Or(
    dbr.Gt("created_at", "2015-09-10"),
    dbr.Lte("created_at", "2015-09-11"),
  ),
  dbr.Eq("title", "hello world"),
)
Built with extensibility

The core of 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 dbr.Expr).

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

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

Driver support

  • MySQL
  • PostgreSQL
  • SQLite3

gocraft

gocraft offers a toolkit for building web apps. Currently these packages are available:

  • gocraft/web - Go Router + Middleware. Your Contexts.
  • mbict/dbr - Additions to Go's database/sql for super fast performance and convenience.
  • gocraft/health - Instrument your web apps with logging and metrics.
  • gocraft/work - Process background jobs in Go.

These packages were developed by the engineering team at UserVoice and currently power much of its infrastructure and tech stack.

Thanks & Authors

Inspiration from these excellent libraries:

  • sqlx - various useful tools and utils for interacting with database/sql.
  • Squirrel - simple fluent query builder.

Authors:

Contributors:

Documentation

Index

Constants

This section is empty.

Variables

View Source
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

View Source
var Now = nowSentinel{}

Now is a value that serializes to the current time

Functions

func InterpolateForDialect

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

InterpolateForDialect replaces placeholder in query with corresponding value in dialect

func Load

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

Load loads any value from sql.Rows

func Union

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

func UnionAll

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

Types

type Buffer

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

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

func NewBuffer

func NewBuffer() Buffer

type BuildFunc

type BuildFunc func(Dialect, Buffer) error

func (BuildFunc) Build

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

type Builder

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

Builder builds sql in one dialect like MySQL/PostgreSQL e.g. XxxBuilder

func And

func And(cond ...Builder) Builder

And creates AND from a list of conditions

func Eq

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

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

Expr should be used when sql syntax is not supported

func Gt

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

Gt is `>`.

func Gte

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

Gte is '>='.

func Lt

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

Lt is '<'.

func Lte

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

Lte is `<=`.

func Neq

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 Or

func Or(cond ...Builder) Builder

Or creates OR from a list of conditions

type Connection

type Connection struct {
	*sql.DB
	Dialect Dialect
	EventReceiver
}

Connection is a connection to the database with an EventReceiver to send events, errors, and timings to

func Open

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

Open instantiates a Connection for a given database/sql connection and event receiver

func (*Connection) NewSession

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

NewSession instantiates a Session for the Connection

type DeleteBuilder

type DeleteBuilder struct {
	EventReceiver
	Dialect Dialect

	*DeleteStmt

	LimitCount int64
	// contains filtered or unexported fields
}

func (*DeleteBuilder) Build

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

func (*DeleteBuilder) Exec

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

func (*DeleteBuilder) ExecContext

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

func (*DeleteBuilder) Limit

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

func (*DeleteBuilder) Where

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

type DeleteStmt

type DeleteStmt struct {
	Table string

	WhereCond []Builder
	// contains filtered or unexported fields
}

DeleteStmt builds `DELETE ...`

func DeleteBySql

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

DeleteBySql creates a DeleteStmt from raw query

func DeleteFrom

func DeleteFrom(table string) *DeleteStmt

DeleteFrom creates a DeleteStmt

func (*DeleteStmt) Build

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

Build builds `DELETE ...` in dialect

func (*DeleteStmt) Where

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

Where adds a where condition

type Dialect

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 differences

type EventReceiver

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

type I string

identifier is a type of string

func (I) As

func (i I) As(alias string) Builder

As creates an alias for expr. e.g. SELECT `a1` AS `a2`

func (I) Build

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

type InsertBuilder

type InsertBuilder struct {
	EventReceiver
	Dialect Dialect

	RecordID reflect.Value

	*InsertStmt
	// contains filtered or unexported fields
}

func (*InsertBuilder) Columns

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

func (*InsertBuilder) Exec

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

func (*InsertBuilder) ExecContext

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

func (*InsertBuilder) ExecContextId

func (b *InsertBuilder) ExecContextId(ctx context.Context) (int64, error)

func (*InsertBuilder) ExecId

func (b *InsertBuilder) ExecId() (int64, error)

func (*InsertBuilder) Load

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

func (*InsertBuilder) LoadContext

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

func (*InsertBuilder) Pair

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

func (*InsertBuilder) Record

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

func (*InsertBuilder) Returning

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

func (*InsertBuilder) Values

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

type InsertStmt

type InsertStmt struct {
	Table        string
	Column       []string
	Value        [][]interface{}
	ReturnColumn []string
	// contains filtered or unexported fields
}

InsertStmt builds `INSERT INTO ...`

func InsertBySql

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

InsertBySql creates an InsertStmt from raw query

func InsertInto

func InsertInto(table string) *InsertStmt

InsertInto creates an InsertStmt

func (*InsertStmt) Build

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

Build builds `INSERT INTO ...` in dialect

func (*InsertStmt) Columns

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

Columns adds columns

func (*InsertStmt) Record

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

Record adds a tuple for columns from a struct

func (*InsertStmt) Returning

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

func (*InsertStmt) Values

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

Values adds a tuple for columns

type NullBool

type NullBool struct {
	sql.NullBool
}

NullBool is a type that can be null or a bool

func NewNullBool

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

func (NullBool) MarshalJSON

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

MarshalJSON correctly serializes a NullBool to JSON

func (*NullBool) UnmarshalJSON

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

UnmarshalJSON correctly deserializes a NullBool from JSON

type NullEventReceiver

type NullEventReceiver struct{}

NullEventReceiver is a sentinel EventReceiver; use it if the caller doesn't supply one

func (*NullEventReceiver) Event

func (n *NullEventReceiver) Event(eventName string)

Event receives a simple notification when various events occur

func (*NullEventReceiver) EventErr

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

EventErr receives a notification of an error if one occurs

func (*NullEventReceiver) EventErrKv

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

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

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

Timing receives the time an event took to happen

func (*NullEventReceiver) TimingKv

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

type NullFloat64 struct {
	sql.NullFloat64
}

NullFloat64 is a type that can be null or a float64

func NewNullFloat64

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

func (NullFloat64) MarshalJSON

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

MarshalJSON correctly serializes a NullFloat64 to JSON

func (*NullFloat64) UnmarshalJSON

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

UnmarshalJSON correctly deserializes a NullFloat64 from JSON

type NullInt64

type NullInt64 struct {
	sql.NullInt64
}

NullInt64 is a type that can be null or an int

func NewNullInt64

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

func (NullInt64) MarshalJSON

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

MarshalJSON correctly serializes a NullInt64 to JSON

func (*NullInt64) UnmarshalJSON

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

UnmarshalJSON correctly deserializes a NullInt64 from JSON

type NullString

type NullString struct {
	sql.NullString
}

NullString is a type that can be null or a string

func NewNullString

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

func (NullString) MarshalJSON

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

MarshalJSON correctly serializes a NullString to JSON

func (*NullString) UnmarshalJSON

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

UnmarshalJSON correctly deserializes a NullString from JSON

type NullTime

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

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

func (NullTime) MarshalJSON

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

MarshalJSON correctly serializes a NullTime to JSON

func (*NullTime) Scan

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

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

UnmarshalJSON correctly deserializes a NullTime from JSON

func (NullTime) Value

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

value implements the driver Valuer interface.

type SelectBuilder

type SelectBuilder struct {
	Dialect Dialect

	*SelectStmt
	// contains filtered or unexported fields
}

func (*SelectBuilder) Count

func (b *SelectBuilder) Count() (uint64, error)

func (*SelectBuilder) CountContext

func (b *SelectBuilder) CountContext(ctx context.Context) (uint64, error)

func (*SelectBuilder) Distinct

func (b *SelectBuilder) Distinct() *SelectBuilder

func (*SelectBuilder) From

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

func (*SelectBuilder) FullJoin

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

func (*SelectBuilder) GroupBy

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

func (*SelectBuilder) Having

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

func (*SelectBuilder) Join

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

func (*SelectBuilder) LeftJoin

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

func (*SelectBuilder) Limit

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

func (*SelectBuilder) Load

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

func (*SelectBuilder) LoadContext

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

func (*SelectBuilder) LoadOne

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

func (*SelectBuilder) LoadOneContext

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

func (*SelectBuilder) Offset

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

func (*SelectBuilder) OrderAsc

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

OrderBy specifies columns for ordering

func (*SelectBuilder) OrderBy

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

func (*SelectBuilder) OrderDesc

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

func (*SelectBuilder) OrderDir

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

func (*SelectBuilder) Paginate

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

func (*SelectBuilder) Query

func (b *SelectBuilder) Query() (*sql.Rows, error)

func (*SelectBuilder) QueryContext

func (b *SelectBuilder) QueryContext(ctx context.Context) (*sql.Rows, error)

func (*SelectBuilder) QueryRow

func (b *SelectBuilder) QueryRow() (*sql.Row, error)

func (*SelectBuilder) QueryRowContext

func (b *SelectBuilder) QueryRowContext(ctx context.Context) (*sql.Row, error)

func (*SelectBuilder) ReturnInt64

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

ReturnInt64 executes the SelectStmt and returns the value as an int64

func (*SelectBuilder) ReturnInt64s

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

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

func (*SelectBuilder) ReturnString

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

ReturnString executes the SelectStmt and returns the value as a string

func (*SelectBuilder) ReturnStrings

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

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

func (*SelectBuilder) ReturnUint64

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

ReturnUint64 executes the SelectStmt and returns the value as an uint64

func (*SelectBuilder) ReturnUint64s

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

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

func (*SelectBuilder) RightJoin

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

func (*SelectBuilder) Select

func (b *SelectBuilder) Select(column ...string) *SelectBuilder

func (*SelectBuilder) Where

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

type SelectStmt

type SelectStmt struct {
	IsDistinct bool

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

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

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

SelectStmt builds `SELECT ...`

func Select

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

Select creates a SelectStmt

func SelectBySql

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

SelectBySql creates a SelectStmt from raw query

func (*SelectStmt) As

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

As creates alias for select statement

func (*SelectStmt) Build

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

Build builds `SELECT ...` in dialect

func (*SelectStmt) Distinct

func (b *SelectStmt) Distinct() *SelectStmt

Distinct adds `DISTINCT`

func (*SelectStmt) From

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

From specifies table

func (*SelectStmt) FullJoin

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

func (*SelectStmt) GroupBy

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

GroupBy specifies columns for grouping

func (*SelectStmt) Having

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

Having adds a having condition

func (*SelectStmt) Join

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

Join joins table on condition

func (*SelectStmt) LeftJoin

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

func (*SelectStmt) Limit

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

Limit adds limit

func (*SelectStmt) Offset

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

Offset adds offset

func (*SelectStmt) OrderAsc

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

OrderBy specifies columns for ordering

func (*SelectStmt) OrderDesc

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

func (*SelectStmt) RightJoin

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

func (*SelectStmt) Select

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

Select create a copy of the select statement with altered columns

func (*SelectStmt) Where

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

Where adds a where condition

type Session

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

Session represents a business unit of execution for some connection

func (*Session) Begin

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

Begin creates a transaction for the given session

func (*Session) BeginTx

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

func (*Session) DeleteBySql

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

func (*Session) DeleteFrom

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

func (*Session) GetTimeout

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

func (*Session) InsertBySql

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

func (*Session) InsertInto

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

func (*Session) Select

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

func (*Session) SelectBySql

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

func (*Session) Update

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

func (*Session) UpdateBySql

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

type SessionRunner

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.

type Tx

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

	// normally we don't call the context cancelFunc.
	// however, if we start a tx without explictly tx,
	// we will need to call this after the transaction.
	Cancel func()
}

Tx is a transaction for the given Session

func (*Tx) Commit

func (tx *Tx) Commit() error

Commit finishes the transaction

func (*Tx) DeleteBySql

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

func (*Tx) DeleteFrom

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

func (*Tx) GetTimeout

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

func (*Tx) InsertBySql

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

func (*Tx) InsertInto

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

func (*Tx) Rollback

func (tx *Tx) Rollback() error

Rollback cancels the transaction

func (*Tx) RollbackUnlessCommitted

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

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

func (*Tx) SelectBySql

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

func (*Tx) Update

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

func (*Tx) UpdateBySql

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

type UpdateBuilder

type UpdateBuilder struct {
	EventReceiver
	Dialect Dialect

	*UpdateStmt

	LimitCount int64
	// contains filtered or unexported fields
}

func (*UpdateBuilder) Build

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

func (*UpdateBuilder) Exec

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

func (*UpdateBuilder) ExecContext

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

func (*UpdateBuilder) Limit

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

func (*UpdateBuilder) Set

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

func (*UpdateBuilder) SetMap

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

func (*UpdateBuilder) Where

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

type UpdateStmt

type UpdateStmt struct {
	Table string
	Value map[string]interface{}

	WhereCond []Builder
	// contains filtered or unexported fields
}

UpdateStmt builds `UPDATE ...`

func Update

func Update(table string) *UpdateStmt

Update creates an UpdateStmt

func UpdateBySql

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

UpdateBySql creates an UpdateStmt with raw query

func (*UpdateStmt) Build

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

Build builds `UPDATE ...` in dialect

func (*UpdateStmt) Set

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

Set specifies a key-value pair

func (*UpdateStmt) SetMap

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

SetMap specifies a list of key-value pair

func (*UpdateStmt) Where

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

Where adds a where condition

Directories

Path Synopsis

Jump to

Keyboard shortcuts

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