dbr

package module
v0.0.0-...-873040a Latest Latest
Warning

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

 Go to latest Published: Aug 12, 2016 License: MIT Imports: 12 Imported by: 0

README

gocraft/dbr (database records) GoDoc

gocraft/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).Load(&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

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

Writing instrumented code is a first-class concern for gocraft/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.

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.

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

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. gocraft/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 gocraft/dbr.

  • Load(&any): load everything!
  • LoadStruct(&oneStruct): load struct
  • LoadStructs(&manyStructs): load a slice of structs
  • LoadValue(&oneValue): load basic type
  • LoadValues(&manyValues): load a slice of basic types
// 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.
  • gocraft/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 Interpolate 

func Interpolate(query string, value []interface{}) (string, error)

FIXME: This will be removed in the future

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 LoadColumns 

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

LoadColumns loads values from sql.Rows, allowing for potentially null values. note: currently only supports NullStrings.

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 NewConnection 

func NewConnection(db *sql.DB, log EventReceiver) *Connection

FIXME: This will be removed in the future

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

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

func (*DeleteBuilder) ToSql 

func (b *DeleteBuilder) ToSql() (string, []interface{})

FIXME: This will be removed in the future

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

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

func (*InsertBuilder) Record 

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

func (*InsertBuilder) ToSql 

func (b *InsertBuilder) ToSql() (string, []interface{})

FIXME: This will be removed in the future

func (*InsertBuilder) Values 

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

type InsertStmt 

type InsertStmt struct {
	Table  string
	Column []string
	Value  [][]interface{}
	// 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) 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 {
	EventReceiver
	Dialect Dialect

	*SelectStmt
	// contains filtered or unexported fields
}

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

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

func (*SelectBuilder) LoadStructs 

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

func (*SelectBuilder) LoadValue 

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

func (*SelectBuilder) LoadValues 

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

func (*SelectBuilder) Offset 

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

func (*SelectBuilder) OrderBy 

func (b *SelectBuilder) OrderBy(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) 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) ToSql 

func (b *SelectBuilder) ToSql() (string, []interface{})

FIXME: This will be removed in the future

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

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

Where adds a where condition

type Session 

type Session struct {
	*Connection
	EventReceiver
}

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

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

func (*Session) DeleteFrom 

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

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
}

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

func (b *UpdateBuilder) ToSql() (string, []interface{})

FIXME: This will be removed in the future

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

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.