README

sqlx

Build Status Coverage Status Godoc license

sqlx is a library which provides a set of extensions on go's standard database/sql library. The sqlx versions of sql.DB, sql.TX, sql.Stmt, et al. all leave the underlying interfaces untouched, so that their interfaces are a superset on the standard ones. This makes it relatively painless to integrate existing codebases using database/sql with sqlx.

Major additional concepts are:

  • Marshal rows into structs (with embedded struct support), maps, and slices
  • Named parameter support including prepared statements
  • Get and Select to go quickly from query to struct/slice

In addition to the godoc API documentation, there is also some user documentation that explains how to use database/sql along with sqlx.

Recent Changes

1.3.0:

  • sqlx.DB.Connx(context.Context) *sqlx.Conn
  • sqlx.BindDriver(driverName, bindType)
  • support for []map[string]interface{} to do "batch" insertions
  • allocation & perf improvements for sqlx.In

DB.Connx returns an sqlx.Conn, which is an sql.Conn-alike consistent with sqlx's wrapping of other types.

BindDriver allows users to control the bindvars that sqlx will use for drivers, and add new drivers at runtime. This results in a very slight performance hit when resolving the driver into a bind type (~40ns per call), but it allows users to specify what bindtype their driver uses even when sqlx has not been updated to know about it by default.

Backwards Compatibility

Compatibility with the most recent two versions of Go is a requirement for any new changes. Compatibility beyond that is not guaranteed.

Versioning is done with Go modules. Breaking changes (eg. removing deprecated API) will get major version number bumps.

install

go get github.com/jmoiron/sqlx

issues

Row headers can be ambiguous (SELECT 1 AS a, 2 AS a), and the result of Columns() does not fully qualify column names in queries like:

SELECT a.id, a.name, b.id, b.name FROM foos AS a JOIN foos AS b ON a.parent = b.id;

making a struct or map destination ambiguous. Use AS in your queries to give columns distinct names, rows.Scan to scan them manually, or SliceScan to get a slice of results.

usage

Below is an example which shows some common use cases for sqlx. Check sqlx_test.go for more usage.

package main

import (
    "database/sql"
    "fmt"
    "log"
    
    _ "github.com/lib/pq"
    "github.com/jmoiron/sqlx"
)

var schema = `
CREATE TABLE person (
    first_name text,
    last_name text,
    email text
);

CREATE TABLE place (
    country text,
    city text NULL,
    telcode integer
)`

type Person struct {
    FirstName string `db:"first_name"`
    LastName  string `db:"last_name"`
    Email     string
}

type Place struct {
    Country string
    City    sql.NullString
    TelCode int
}

func main() {
    // this Pings the database trying to connect
    // use sqlx.Open() for sql.Open() semantics
    db, err := sqlx.Connect("postgres", "user=foo dbname=bar sslmode=disable")
    if err != nil {
        log.Fatalln(err)
    }

    // exec the schema or fail; multi-statement Exec behavior varies between
    // database drivers;  pq will exec them all, sqlite3 won't, ymmv
    db.MustExec(schema)
    
    tx := db.MustBegin()
    tx.MustExec("INSERT INTO person (first_name, last_name, email) VALUES ($1, $2, $3)", "Jason", "Moiron", "jmoiron@jmoiron.net")
    tx.MustExec("INSERT INTO person (first_name, last_name, email) VALUES ($1, $2, $3)", "John", "Doe", "johndoeDNE@gmail.net")
    tx.MustExec("INSERT INTO place (country, city, telcode) VALUES ($1, $2, $3)", "United States", "New York", "1")
    tx.MustExec("INSERT INTO place (country, telcode) VALUES ($1, $2)", "Hong Kong", "852")
    tx.MustExec("INSERT INTO place (country, telcode) VALUES ($1, $2)", "Singapore", "65")
    // Named queries can use structs, so if you have an existing struct (i.e. person := &Person{}) that you have populated, you can pass it in as &person
    tx.NamedExec("INSERT INTO person (first_name, last_name, email) VALUES (:first_name, :last_name, :email)", &Person{"Jane", "Citizen", "jane.citzen@example.com"})
    tx.Commit()

    // Query the database, storing results in a []Person (wrapped in []interface{})
    people := []Person{}
    db.Select(&people, "SELECT * FROM person ORDER BY first_name ASC")
    jason, john := people[0], people[1]

    fmt.Printf("%#v\n%#v", jason, john)
    // Person{FirstName:"Jason", LastName:"Moiron", Email:"jmoiron@jmoiron.net"}
    // Person{FirstName:"John", LastName:"Doe", Email:"johndoeDNE@gmail.net"}

    // You can also get a single result, a la QueryRow
    jason = Person{}
    err = db.Get(&jason, "SELECT * FROM person WHERE first_name=$1", "Jason")
    fmt.Printf("%#v\n", jason)
    // Person{FirstName:"Jason", LastName:"Moiron", Email:"jmoiron@jmoiron.net"}

    // if you have null fields and use SELECT *, you must use sql.Null* in your struct
    places := []Place{}
    err = db.Select(&places, "SELECT * FROM place ORDER BY telcode ASC")
    if err != nil {
        fmt.Println(err)
        return
    }
    usa, singsing, honkers := places[0], places[1], places[2]
    
    fmt.Printf("%#v\n%#v\n%#v\n", usa, singsing, honkers)
    // Place{Country:"United States", City:sql.NullString{String:"New York", Valid:true}, TelCode:1}
    // Place{Country:"Singapore", City:sql.NullString{String:"", Valid:false}, TelCode:65}
    // Place{Country:"Hong Kong", City:sql.NullString{String:"", Valid:false}, TelCode:852}

    // Loop through rows using only one struct
    place := Place{}
    rows, err := db.Queryx("SELECT * FROM place")
    for rows.Next() {
        err := rows.StructScan(&place)
        if err != nil {
            log.Fatalln(err)
        } 
        fmt.Printf("%#v\n", place)
    }
    // Place{Country:"United States", City:sql.NullString{String:"New York", Valid:true}, TelCode:1}
    // Place{Country:"Hong Kong", City:sql.NullString{String:"", Valid:false}, TelCode:852}
    // Place{Country:"Singapore", City:sql.NullString{String:"", Valid:false}, TelCode:65}

    // Named queries, using `:name` as the bindvar.  Automatic bindvar support
    // which takes into account the dbtype based on the driverName on sqlx.Open/Connect
    _, err = db.NamedExec(`INSERT INTO person (first_name,last_name,email) VALUES (:first,:last,:email)`, 
        map[string]interface{}{
            "first": "Bin",
            "last": "Smuth",
            "email": "bensmith@allblacks.nz",
    })

    // Selects Mr. Smith from the database
    rows, err = db.NamedQuery(`SELECT * FROM person WHERE first_name=:fn`, map[string]interface{}{"fn": "Bin"})

    // Named queries can also use structs.  Their bind names follow the same rules
    // as the name -> db mapping, so struct fields are lowercased and the `db` tag
    // is taken into consideration.
    rows, err = db.NamedQuery(`SELECT * FROM person WHERE first_name=:first_name`, jason)
    
    
    // batch insert
    
    // batch insert with structs
    personStructs := []Person{
        {FirstName: "Ardie", LastName: "Savea", Email: "asavea@ab.co.nz"},
        {FirstName: "Sonny Bill", LastName: "Williams", Email: "sbw@ab.co.nz"},
        {FirstName: "Ngani", LastName: "Laumape", Email: "nlaumape@ab.co.nz"},
    }

    _, err = db.NamedExec(`INSERT INTO person (first_name, last_name, email)
        VALUES (:first_name, :last_name, :email)`, personStructs)

    // batch insert with maps
    personMaps := []map[string]interface{}{
        {"first_name": "Ardie", "last_name": "Savea", "email": "asavea@ab.co.nz"},
        {"first_name": "Sonny Bill", "last_name": "Williams", "email": "sbw@ab.co.nz"},
        {"first_name": "Ngani", "last_name": "Laumape", "email": "nlaumape@ab.co.nz"},
    }

    _, err = db.NamedExec(`INSERT INTO person (first_name, last_name, email)
        VALUES (:first_name, :last_name, :email)`, personMaps)
}
Expand ▾ Collapse ▴

Documentation

Overview

    Package sqlx provides general purpose extensions to database/sql.

    It is intended to seamlessly wrap database/sql and provide convenience methods which are useful in the development of database driven applications. None of the underlying database/sql methods are changed. Instead all extended behavior is implemented through new methods defined on wrapper types.

    Additions include scanning into structs, named query support, rebinding queries for different drivers, convenient shorthands for common error handling and more.

    Index

    Constants

    View Source
    const (
    	UNKNOWN = iota
    	QUESTION
    	DOLLAR
    	NAMED
    	AT
    )

      Bindvar types supported by Rebind, BindMap and BindStruct.

      Variables

      View Source
      var NameMapper = strings.ToLower

        NameMapper is used to map column names to struct field names. By default, it uses strings.ToLower to lowercase struct field names. It can be set to whatever you want, but it is encouraged to be set before sqlx is used as name-to-field mappings are cached after first use on a type.

        Functions

        func BindDriver

        func BindDriver(driverName string, bindType int)

          BindDriver sets the BindType for driverName to bindType.

          func BindNamed

          func BindNamed(bindType int, query string, arg interface{}) (string, []interface{}, error)

            BindNamed binds a struct or a map to a query with named parameters. DEPRECATED: use sqlx.Named` instead of this, it may be removed in future.

            func BindType

            func BindType(driverName string) int

              BindType returns the bindtype for a given database given a drivername.

              func Get

              func Get(q Queryer, dest interface{}, query string, args ...interface{}) error

                Get does a QueryRow using the provided Queryer, and scans the resulting row to dest. If dest is scannable, the result must only have one column. Otherwise, StructScan is used. Get will return sql.ErrNoRows like row.Scan would. Any placeholder parameters are replaced with supplied args. An error is returned if the result set is empty.

                func GetContext

                func GetContext(ctx context.Context, q QueryerContext, dest interface{}, query string, args ...interface{}) error

                  GetContext does a QueryRow using the provided Queryer, and scans the resulting row to dest. If dest is scannable, the result must only have one column. Otherwise, StructScan is used. Get will return sql.ErrNoRows like row.Scan would. Any placeholder parameters are replaced with supplied args. An error is returned if the result set is empty.

                  func In

                  func In(query string, args ...interface{}) (string, []interface{}, error)

                    In expands slice values in args, returning the modified query string and a new arg list that can be executed by a database. The `query` should use the `?` bindVar. The return value uses the `?` bindVar.

                    func LoadFile

                    func LoadFile(e Execer, path string) (*sql.Result, error)

                      LoadFile exec's every statement in a file (as a single call to Exec). LoadFile may return a nil *sql.Result if errors are encountered locating or reading the file at path. LoadFile reads the entire file into memory, so it is not suitable for loading large data dumps, but can be useful for initializing schemas or loading indexes.

                      FIXME: this does not really work with multi-statement files for mattn/go-sqlite3 or the go-mysql-driver/mysql drivers; pq seems to be an exception here. Detecting this by requiring something with DriverName() and then attempting to split the queries will be difficult to get right, and its current driver-specific behavior is deemed at least not complex in its incorrectness.

                      func LoadFileContext

                      func LoadFileContext(ctx context.Context, e ExecerContext, path string) (*sql.Result, error)

                        LoadFileContext exec's every statement in a file (as a single call to Exec). LoadFileContext may return a nil *sql.Result if errors are encountered locating or reading the file at path. LoadFile reads the entire file into memory, so it is not suitable for loading large data dumps, but can be useful for initializing schemas or loading indexes.

                        FIXME: this does not really work with multi-statement files for mattn/go-sqlite3 or the go-mysql-driver/mysql drivers; pq seems to be an exception here. Detecting this by requiring something with DriverName() and then attempting to split the queries will be difficult to get right, and its current driver-specific behavior is deemed at least not complex in its incorrectness.

                        func MapScan

                        func MapScan(r ColScanner, dest map[string]interface{}) error

                          MapScan scans a single Row into the dest map[string]interface{}. Use this to get results for SQL that might not be under your control (for instance, if you're building an interface for an SQL server that executes SQL from input). Please do not use this as a primary interface! This will modify the map sent to it in place, so reuse the same map with care. Columns which occur more than once in the result will overwrite each other!

                          func MustExec

                          func MustExec(e Execer, query string, args ...interface{}) sql.Result

                            MustExec execs the query using e and panics if there was an error. Any placeholder parameters are replaced with supplied args.

                            func MustExecContext

                            func MustExecContext(ctx context.Context, e ExecerContext, query string, args ...interface{}) sql.Result

                              MustExecContext execs the query using e and panics if there was an error. Any placeholder parameters are replaced with supplied args.

                              func Named

                              func Named(query string, arg interface{}) (string, []interface{}, error)

                                Named takes a query using named parameters and an argument and returns a new query with a list of args that can be executed by a database. The return value uses the `?` bindvar.

                                func NamedExec

                                func NamedExec(e Ext, query string, arg interface{}) (sql.Result, error)

                                  NamedExec uses BindStruct to get a query executable by the driver and then runs Exec on the result. Returns an error from the binding or the query execution itself.

                                  func NamedExecContext

                                  func NamedExecContext(ctx context.Context, e ExtContext, query string, arg interface{}) (sql.Result, error)

                                    NamedExecContext uses BindStruct to get a query executable by the driver and then runs Exec on the result. Returns an error from the binding or the query execution itself.

                                    func Rebind

                                    func Rebind(bindType int, query string) string

                                      Rebind a query from the default bindtype (QUESTION) to the target bindtype.

                                      func Select

                                      func Select(q Queryer, dest interface{}, query string, args ...interface{}) error

                                        Select executes a query using the provided Queryer, and StructScans each row into dest, which must be a slice. If the slice elements are scannable, then the result set must have only one column. Otherwise, StructScan is used. The *sql.Rows are closed automatically. Any placeholder parameters are replaced with supplied args.

                                        func SelectContext

                                        func SelectContext(ctx context.Context, q QueryerContext, dest interface{}, query string, args ...interface{}) error

                                          SelectContext executes a query using the provided Queryer, and StructScans each row into dest, which must be a slice. If the slice elements are scannable, then the result set must have only one column. Otherwise, StructScan is used. The *sql.Rows are closed automatically. Any placeholder parameters are replaced with supplied args.

                                          func SliceScan

                                          func SliceScan(r ColScanner) ([]interface{}, error)

                                            SliceScan a row, returning a []interface{} with values similar to MapScan. This function is primarily intended for use where the number of columns is not known. Because you can pass an []interface{} directly to Scan, it's recommended that you do that as it will not have to allocate new slices per row.

                                            func StructScan

                                            func StructScan(rows rowsi, dest interface{}) error

                                              StructScan all rows from an sql.Rows or an sqlx.Rows into the dest slice. StructScan will scan in the entire rows result, so if you do not want to allocate structs for the entire result, use Queryx and see sqlx.Rows.StructScan. If rows is sqlx.Rows, it will use its mapper, otherwise it will use the default.

                                              Types

                                              type ColScanner

                                              type ColScanner interface {
                                              	Columns() ([]string, error)
                                              	Scan(dest ...interface{}) error
                                              	Err() error
                                              }

                                                ColScanner is an interface used by MapScan and SliceScan

                                                type Conn

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

                                                  Conn is a wrapper around sql.Conn with extra functionality

                                                  func (*Conn) BeginTxx

                                                  func (c *Conn) BeginTxx(ctx context.Context, opts *sql.TxOptions) (*Tx, error)

                                                    BeginTxx begins a transaction and returns an *sqlx.Tx instead of an *sql.Tx.

                                                    The provided context is used until the transaction is committed or rolled back. If the context is canceled, the sql package will roll back the transaction. Tx.Commit will return an error if the context provided to BeginxContext is canceled.

                                                    func (*Conn) GetContext

                                                    func (c *Conn) GetContext(ctx context.Context, dest interface{}, query string, args ...interface{}) error

                                                      GetContext using this Conn. Any placeholder parameters are replaced with supplied args. An error is returned if the result set is empty.

                                                      func (*Conn) PreparexContext

                                                      func (c *Conn) PreparexContext(ctx context.Context, query string) (*Stmt, error)

                                                        PreparexContext returns an sqlx.Stmt instead of a sql.Stmt.

                                                        The provided context is used for the preparation of the statement, not for the execution of the statement.

                                                        func (*Conn) QueryRowxContext

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

                                                          QueryRowxContext queries the database and returns an *sqlx.Row. Any placeholder parameters are replaced with supplied args.

                                                          func (*Conn) QueryxContext

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

                                                            QueryxContext queries the database and returns an *sqlx.Rows. Any placeholder parameters are replaced with supplied args.

                                                            func (*Conn) Rebind

                                                            func (c *Conn) Rebind(query string) string

                                                              Rebind a query within a Conn's bindvar type.

                                                              func (*Conn) SelectContext

                                                              func (c *Conn) SelectContext(ctx context.Context, dest interface{}, query string, args ...interface{}) error

                                                                SelectContext using this Conn. Any placeholder parameters are replaced with supplied args.

                                                                type DB

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

                                                                  DB is a wrapper around sql.DB which keeps track of the driverName upon Open, used mostly to automatically bind named queries using the right bindvars.

                                                                  func Connect

                                                                  func Connect(driverName, dataSourceName string) (*DB, error)

                                                                    Connect to a database and verify with a ping.

                                                                    func ConnectContext

                                                                    func ConnectContext(ctx context.Context, driverName, dataSourceName string) (*DB, error)

                                                                      ConnectContext to a database and verify with a ping.

                                                                      func MustConnect

                                                                      func MustConnect(driverName, dataSourceName string) *DB

                                                                        MustConnect connects to a database and panics on error.

                                                                        func MustOpen

                                                                        func MustOpen(driverName, dataSourceName string) *DB

                                                                          MustOpen is the same as sql.Open, but returns an *sqlx.DB instead and panics on error.

                                                                          func NewDb

                                                                          func NewDb(db *sql.DB, driverName string) *DB

                                                                            NewDb returns a new sqlx DB wrapper for a pre-existing *sql.DB. The driverName of the original database is required for named query support.

                                                                            func Open

                                                                            func Open(driverName, dataSourceName string) (*DB, error)

                                                                              Open is the same as sql.Open, but returns an *sqlx.DB instead.

                                                                              func (*DB) BeginTxx

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

                                                                                BeginTxx begins a transaction and returns an *sqlx.Tx instead of an *sql.Tx.

                                                                                The provided context is used until the transaction is committed or rolled back. If the context is canceled, the sql package will roll back the transaction. Tx.Commit will return an error if the context provided to BeginxContext is canceled.

                                                                                func (*DB) Beginx

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

                                                                                  Beginx begins a transaction and returns an *sqlx.Tx instead of an *sql.Tx.

                                                                                  func (*DB) BindNamed

                                                                                  func (db *DB) BindNamed(query string, arg interface{}) (string, []interface{}, error)

                                                                                    BindNamed binds a query using the DB driver's bindvar type.

                                                                                    func (*DB) Connx

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

                                                                                      Connx returns an *sqlx.Conn instead of an *sql.Conn.

                                                                                      func (*DB) DriverName

                                                                                      func (db *DB) DriverName() string

                                                                                        DriverName returns the driverName passed to the Open function for this DB.

                                                                                        func (*DB) Get

                                                                                        func (db *DB) Get(dest interface{}, query string, args ...interface{}) error

                                                                                          Get using this DB. Any placeholder parameters are replaced with supplied args. An error is returned if the result set is empty.

                                                                                          func (*DB) GetContext

                                                                                          func (db *DB) GetContext(ctx context.Context, dest interface{}, query string, args ...interface{}) error

                                                                                            GetContext using this DB. Any placeholder parameters are replaced with supplied args. An error is returned if the result set is empty.

                                                                                            func (*DB) MapperFunc

                                                                                            func (db *DB) MapperFunc(mf func(string) string)

                                                                                              MapperFunc sets a new mapper for this db using the default sqlx struct tag and the provided mapper function.

                                                                                              func (*DB) MustBegin

                                                                                              func (db *DB) MustBegin() *Tx

                                                                                                MustBegin starts a transaction, and panics on error. Returns an *sqlx.Tx instead of an *sql.Tx.

                                                                                                func (*DB) MustBeginTx

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

                                                                                                  MustBeginTx starts a transaction, and panics on error. Returns an *sqlx.Tx instead of an *sql.Tx.

                                                                                                  The provided context is used until the transaction is committed or rolled back. If the context is canceled, the sql package will roll back the transaction. Tx.Commit will return an error if the context provided to MustBeginContext is canceled.

                                                                                                  func (*DB) MustExec

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

                                                                                                    MustExec (panic) runs MustExec using this database. Any placeholder parameters are replaced with supplied args.

                                                                                                    func (*DB) MustExecContext

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

                                                                                                      MustExecContext (panic) runs MustExec using this database. Any placeholder parameters are replaced with supplied args.

                                                                                                      func (*DB) NamedExec

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

                                                                                                        NamedExec using this DB. Any named placeholder parameters are replaced with fields from arg.

                                                                                                        func (*DB) NamedExecContext

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

                                                                                                          NamedExecContext using this DB. Any named placeholder parameters are replaced with fields from arg.

                                                                                                          func (*DB) NamedQuery

                                                                                                          func (db *DB) NamedQuery(query string, arg interface{}) (*Rows, error)

                                                                                                            NamedQuery using this DB. Any named placeholder parameters are replaced with fields from arg.

                                                                                                            func (*DB) NamedQueryContext

                                                                                                            func (db *DB) NamedQueryContext(ctx context.Context, query string, arg interface{}) (*Rows, error)

                                                                                                              NamedQueryContext using this DB. Any named placeholder parameters are replaced with fields from arg.

                                                                                                              func (*DB) PrepareNamed

                                                                                                              func (db *DB) PrepareNamed(query string) (*NamedStmt, error)

                                                                                                                PrepareNamed returns an sqlx.NamedStmt

                                                                                                                func (*DB) PrepareNamedContext

                                                                                                                func (db *DB) PrepareNamedContext(ctx context.Context, query string) (*NamedStmt, error)

                                                                                                                  PrepareNamedContext returns an sqlx.NamedStmt

                                                                                                                  func (*DB) Preparex

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

                                                                                                                    Preparex returns an sqlx.Stmt instead of a sql.Stmt

                                                                                                                    func (*DB) PreparexContext

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

                                                                                                                      PreparexContext returns an sqlx.Stmt instead of a sql.Stmt.

                                                                                                                      The provided context is used for the preparation of the statement, not for the execution of the statement.

                                                                                                                      func (*DB) QueryRowx

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

                                                                                                                        QueryRowx queries the database and returns an *sqlx.Row. Any placeholder parameters are replaced with supplied args.

                                                                                                                        func (*DB) QueryRowxContext

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

                                                                                                                          QueryRowxContext queries the database and returns an *sqlx.Row. Any placeholder parameters are replaced with supplied args.

                                                                                                                          func (*DB) Queryx

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

                                                                                                                            Queryx queries the database and returns an *sqlx.Rows. Any placeholder parameters are replaced with supplied args.

                                                                                                                            func (*DB) QueryxContext

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

                                                                                                                              QueryxContext queries the database and returns an *sqlx.Rows. Any placeholder parameters are replaced with supplied args.

                                                                                                                              func (*DB) Rebind

                                                                                                                              func (db *DB) Rebind(query string) string

                                                                                                                                Rebind transforms a query from QUESTION to the DB driver's bindvar type.

                                                                                                                                func (*DB) Select

                                                                                                                                func (db *DB) Select(dest interface{}, query string, args ...interface{}) error

                                                                                                                                  Select using this DB. Any placeholder parameters are replaced with supplied args.

                                                                                                                                  func (*DB) SelectContext

                                                                                                                                  func (db *DB) SelectContext(ctx context.Context, dest interface{}, query string, args ...interface{}) error

                                                                                                                                    SelectContext using this DB. Any placeholder parameters are replaced with supplied args.

                                                                                                                                    func (*DB) Unsafe

                                                                                                                                    func (db *DB) Unsafe() *DB

                                                                                                                                      Unsafe returns a version of DB which will silently succeed to scan when columns in the SQL result have no fields in the destination struct. sqlx.Stmt and sqlx.Tx which are created from this DB will inherit its safety behavior.

                                                                                                                                      type Execer

                                                                                                                                      type Execer interface {
                                                                                                                                      	Exec(query string, args ...interface{}) (sql.Result, error)
                                                                                                                                      }

                                                                                                                                        Execer is an interface used by MustExec and LoadFile

                                                                                                                                        type ExecerContext

                                                                                                                                        type ExecerContext interface {
                                                                                                                                        	ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error)
                                                                                                                                        }

                                                                                                                                          ExecerContext is an interface used by MustExecContext and LoadFileContext

                                                                                                                                          type Ext

                                                                                                                                          type Ext interface {
                                                                                                                                          	Queryer
                                                                                                                                          	Execer
                                                                                                                                          	// contains filtered or unexported methods
                                                                                                                                          }

                                                                                                                                            Ext is a union interface which can bind, query, and exec, used by NamedQuery and NamedExec.

                                                                                                                                            type ExtContext

                                                                                                                                            type ExtContext interface {
                                                                                                                                            	QueryerContext
                                                                                                                                            	ExecerContext
                                                                                                                                            	// contains filtered or unexported methods
                                                                                                                                            }

                                                                                                                                              ExtContext is a union interface which can bind, query, and exec, with Context used by NamedQueryContext and NamedExecContext.

                                                                                                                                              type NamedStmt

                                                                                                                                              type NamedStmt struct {
                                                                                                                                              	Params      []string
                                                                                                                                              	QueryString string
                                                                                                                                              	Stmt        *Stmt
                                                                                                                                              }

                                                                                                                                                NamedStmt is a prepared statement that executes named queries. Prepare it how you would execute a NamedQuery, but pass in a struct or map when executing.

                                                                                                                                                func (*NamedStmt) Close

                                                                                                                                                func (n *NamedStmt) Close() error

                                                                                                                                                  Close closes the named statement.

                                                                                                                                                  func (*NamedStmt) Exec

                                                                                                                                                  func (n *NamedStmt) Exec(arg interface{}) (sql.Result, error)

                                                                                                                                                    Exec executes a named statement using the struct passed. Any named placeholder parameters are replaced with fields from arg.

                                                                                                                                                    func (*NamedStmt) ExecContext

                                                                                                                                                    func (n *NamedStmt) ExecContext(ctx context.Context, arg interface{}) (sql.Result, error)

                                                                                                                                                      ExecContext executes a named statement using the struct passed. Any named placeholder parameters are replaced with fields from arg.

                                                                                                                                                      func (*NamedStmt) Get

                                                                                                                                                      func (n *NamedStmt) Get(dest interface{}, arg interface{}) error

                                                                                                                                                        Get using this NamedStmt Any named placeholder parameters are replaced with fields from arg.

                                                                                                                                                        func (*NamedStmt) GetContext

                                                                                                                                                        func (n *NamedStmt) GetContext(ctx context.Context, dest interface{}, arg interface{}) error

                                                                                                                                                          GetContext using this NamedStmt Any named placeholder parameters are replaced with fields from arg.

                                                                                                                                                          func (*NamedStmt) MustExec

                                                                                                                                                          func (n *NamedStmt) MustExec(arg interface{}) sql.Result

                                                                                                                                                            MustExec execs a NamedStmt, panicing on error Any named placeholder parameters are replaced with fields from arg.

                                                                                                                                                            func (*NamedStmt) MustExecContext

                                                                                                                                                            func (n *NamedStmt) MustExecContext(ctx context.Context, arg interface{}) sql.Result

                                                                                                                                                              MustExecContext execs a NamedStmt, panicing on error Any named placeholder parameters are replaced with fields from arg.

                                                                                                                                                              func (*NamedStmt) Query

                                                                                                                                                              func (n *NamedStmt) Query(arg interface{}) (*sql.Rows, error)

                                                                                                                                                                Query executes a named statement using the struct argument, returning rows. Any named placeholder parameters are replaced with fields from arg.

                                                                                                                                                                func (*NamedStmt) QueryContext

                                                                                                                                                                func (n *NamedStmt) QueryContext(ctx context.Context, arg interface{}) (*sql.Rows, error)

                                                                                                                                                                  QueryContext executes a named statement using the struct argument, returning rows. Any named placeholder parameters are replaced with fields from arg.

                                                                                                                                                                  func (*NamedStmt) QueryRow

                                                                                                                                                                  func (n *NamedStmt) QueryRow(arg interface{}) *Row

                                                                                                                                                                    QueryRow executes a named statement against the database. Because sqlx cannot create a *sql.Row with an error condition pre-set for binding errors, sqlx returns a *sqlx.Row instead. Any named placeholder parameters are replaced with fields from arg.

                                                                                                                                                                    func (*NamedStmt) QueryRowContext

                                                                                                                                                                    func (n *NamedStmt) QueryRowContext(ctx context.Context, arg interface{}) *Row

                                                                                                                                                                      QueryRowContext executes a named statement against the database. Because sqlx cannot create a *sql.Row with an error condition pre-set for binding errors, sqlx returns a *sqlx.Row instead. Any named placeholder parameters are replaced with fields from arg.

                                                                                                                                                                      func (*NamedStmt) QueryRowx

                                                                                                                                                                      func (n *NamedStmt) QueryRowx(arg interface{}) *Row

                                                                                                                                                                        QueryRowx this NamedStmt. Because of limitations with QueryRow, this is an alias for QueryRow. Any named placeholder parameters are replaced with fields from arg.

                                                                                                                                                                        func (*NamedStmt) QueryRowxContext

                                                                                                                                                                        func (n *NamedStmt) QueryRowxContext(ctx context.Context, arg interface{}) *Row

                                                                                                                                                                          QueryRowxContext this NamedStmt. Because of limitations with QueryRow, this is an alias for QueryRow. Any named placeholder parameters are replaced with fields from arg.

                                                                                                                                                                          func (*NamedStmt) Queryx

                                                                                                                                                                          func (n *NamedStmt) Queryx(arg interface{}) (*Rows, error)

                                                                                                                                                                            Queryx using this NamedStmt Any named placeholder parameters are replaced with fields from arg.

                                                                                                                                                                            func (*NamedStmt) QueryxContext

                                                                                                                                                                            func (n *NamedStmt) QueryxContext(ctx context.Context, arg interface{}) (*Rows, error)

                                                                                                                                                                              QueryxContext using this NamedStmt Any named placeholder parameters are replaced with fields from arg.

                                                                                                                                                                              func (*NamedStmt) Select

                                                                                                                                                                              func (n *NamedStmt) Select(dest interface{}, arg interface{}) error

                                                                                                                                                                                Select using this NamedStmt Any named placeholder parameters are replaced with fields from arg.

                                                                                                                                                                                func (*NamedStmt) SelectContext

                                                                                                                                                                                func (n *NamedStmt) SelectContext(ctx context.Context, dest interface{}, arg interface{}) error

                                                                                                                                                                                  SelectContext using this NamedStmt Any named placeholder parameters are replaced with fields from arg.

                                                                                                                                                                                  func (*NamedStmt) Unsafe

                                                                                                                                                                                  func (n *NamedStmt) Unsafe() *NamedStmt

                                                                                                                                                                                    Unsafe creates an unsafe version of the NamedStmt

                                                                                                                                                                                    type Preparer

                                                                                                                                                                                    type Preparer interface {
                                                                                                                                                                                    	Prepare(query string) (*sql.Stmt, error)
                                                                                                                                                                                    }

                                                                                                                                                                                      Preparer is an interface used by Preparex.

                                                                                                                                                                                      type PreparerContext

                                                                                                                                                                                      type PreparerContext interface {
                                                                                                                                                                                      	PrepareContext(ctx context.Context, query string) (*sql.Stmt, error)
                                                                                                                                                                                      }

                                                                                                                                                                                        PreparerContext is an interface used by PreparexContext.

                                                                                                                                                                                        type Queryer

                                                                                                                                                                                        type Queryer interface {
                                                                                                                                                                                        	Query(query string, args ...interface{}) (*sql.Rows, error)
                                                                                                                                                                                        	Queryx(query string, args ...interface{}) (*Rows, error)
                                                                                                                                                                                        	QueryRowx(query string, args ...interface{}) *Row
                                                                                                                                                                                        }

                                                                                                                                                                                          Queryer is an interface used by Get and Select

                                                                                                                                                                                          type QueryerContext

                                                                                                                                                                                          type QueryerContext interface {
                                                                                                                                                                                          	QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error)
                                                                                                                                                                                          	QueryxContext(ctx context.Context, query string, args ...interface{}) (*Rows, error)
                                                                                                                                                                                          	QueryRowxContext(ctx context.Context, query string, args ...interface{}) *Row
                                                                                                                                                                                          }

                                                                                                                                                                                            QueryerContext is an interface used by GetContext and SelectContext

                                                                                                                                                                                            type Row

                                                                                                                                                                                            type Row struct {
                                                                                                                                                                                            	Mapper *reflectx.Mapper
                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                            }

                                                                                                                                                                                              Row is a reimplementation of sql.Row in order to gain access to the underlying sql.Rows.Columns() data, necessary for StructScan.

                                                                                                                                                                                              func (*Row) ColumnTypes

                                                                                                                                                                                              func (r *Row) ColumnTypes() ([]*sql.ColumnType, error)

                                                                                                                                                                                                ColumnTypes returns the underlying sql.Rows.ColumnTypes(), or the deferred error

                                                                                                                                                                                                func (*Row) Columns

                                                                                                                                                                                                func (r *Row) Columns() ([]string, error)

                                                                                                                                                                                                  Columns returns the underlying sql.Rows.Columns(), or the deferred error usually returned by Row.Scan()

                                                                                                                                                                                                  func (*Row) Err

                                                                                                                                                                                                  func (r *Row) Err() error

                                                                                                                                                                                                    Err returns the error encountered while scanning.

                                                                                                                                                                                                    func (*Row) MapScan

                                                                                                                                                                                                    func (r *Row) MapScan(dest map[string]interface{}) error

                                                                                                                                                                                                      MapScan using this Rows.

                                                                                                                                                                                                      func (*Row) Scan

                                                                                                                                                                                                      func (r *Row) Scan(dest ...interface{}) error

                                                                                                                                                                                                        Scan is a fixed implementation of sql.Row.Scan, which does not discard the underlying error from the internal rows object if it exists.

                                                                                                                                                                                                        func (*Row) SliceScan

                                                                                                                                                                                                        func (r *Row) SliceScan() ([]interface{}, error)

                                                                                                                                                                                                          SliceScan using this Rows.

                                                                                                                                                                                                          func (*Row) StructScan

                                                                                                                                                                                                          func (r *Row) StructScan(dest interface{}) error

                                                                                                                                                                                                            StructScan a single Row into dest.

                                                                                                                                                                                                            type Rows

                                                                                                                                                                                                            type Rows struct {
                                                                                                                                                                                                            	*sql.Rows
                                                                                                                                                                                                            
                                                                                                                                                                                                            	Mapper *reflectx.Mapper
                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                            }

                                                                                                                                                                                                              Rows is a wrapper around sql.Rows which caches costly reflect operations during a looped StructScan

                                                                                                                                                                                                              func NamedQuery

                                                                                                                                                                                                              func NamedQuery(e Ext, query string, arg interface{}) (*Rows, error)

                                                                                                                                                                                                                NamedQuery binds a named query and then runs Query on the result using the provided Ext (sqlx.Tx, sqlx.Db). It works with both structs and with map[string]interface{} types.

                                                                                                                                                                                                                func NamedQueryContext

                                                                                                                                                                                                                func NamedQueryContext(ctx context.Context, e ExtContext, query string, arg interface{}) (*Rows, error)

                                                                                                                                                                                                                  NamedQueryContext binds a named query and then runs Query on the result using the provided Ext (sqlx.Tx, sqlx.Db). It works with both structs and with map[string]interface{} types.

                                                                                                                                                                                                                  func (*Rows) MapScan

                                                                                                                                                                                                                  func (r *Rows) MapScan(dest map[string]interface{}) error

                                                                                                                                                                                                                    MapScan using this Rows.

                                                                                                                                                                                                                    func (*Rows) SliceScan

                                                                                                                                                                                                                    func (r *Rows) SliceScan() ([]interface{}, error)

                                                                                                                                                                                                                      SliceScan using this Rows.

                                                                                                                                                                                                                      func (*Rows) StructScan

                                                                                                                                                                                                                      func (r *Rows) StructScan(dest interface{}) error

                                                                                                                                                                                                                        StructScan is like sql.Rows.Scan, but scans a single Row into a single Struct. Use this and iterate over Rows manually when the memory load of Select() might be prohibitive. *Rows.StructScan caches the reflect work of matching up column positions to fields to avoid that overhead per scan, which means it is not safe to run StructScan on the same Rows instance with different struct types.

                                                                                                                                                                                                                        type Stmt

                                                                                                                                                                                                                        type Stmt struct {
                                                                                                                                                                                                                        	*sql.Stmt
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	Mapper *reflectx.Mapper
                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                        }

                                                                                                                                                                                                                          Stmt is an sqlx wrapper around sql.Stmt with extra functionality

                                                                                                                                                                                                                          func Preparex

                                                                                                                                                                                                                          func Preparex(p Preparer, query string) (*Stmt, error)

                                                                                                                                                                                                                            Preparex prepares a statement.

                                                                                                                                                                                                                            func PreparexContext

                                                                                                                                                                                                                            func PreparexContext(ctx context.Context, p PreparerContext, query string) (*Stmt, error)

                                                                                                                                                                                                                              PreparexContext prepares a statement.

                                                                                                                                                                                                                              The provided context is used for the preparation of the statement, not for the execution of the statement.

                                                                                                                                                                                                                              func (*Stmt) Get

                                                                                                                                                                                                                              func (s *Stmt) Get(dest interface{}, args ...interface{}) error

                                                                                                                                                                                                                                Get using the prepared statement. Any placeholder parameters are replaced with supplied args. An error is returned if the result set is empty.

                                                                                                                                                                                                                                func (*Stmt) GetContext

                                                                                                                                                                                                                                func (s *Stmt) GetContext(ctx context.Context, dest interface{}, args ...interface{}) error

                                                                                                                                                                                                                                  GetContext using the prepared statement. Any placeholder parameters are replaced with supplied args. An error is returned if the result set is empty.

                                                                                                                                                                                                                                  func (*Stmt) MustExec

                                                                                                                                                                                                                                  func (s *Stmt) MustExec(args ...interface{}) sql.Result

                                                                                                                                                                                                                                    MustExec (panic) using this statement. Note that the query portion of the error output will be blank, as Stmt does not expose its query. Any placeholder parameters are replaced with supplied args.

                                                                                                                                                                                                                                    func (*Stmt) MustExecContext

                                                                                                                                                                                                                                    func (s *Stmt) MustExecContext(ctx context.Context, args ...interface{}) sql.Result

                                                                                                                                                                                                                                      MustExecContext (panic) using this statement. Note that the query portion of the error output will be blank, as Stmt does not expose its query. Any placeholder parameters are replaced with supplied args.

                                                                                                                                                                                                                                      func (*Stmt) QueryRowx

                                                                                                                                                                                                                                      func (s *Stmt) QueryRowx(args ...interface{}) *Row

                                                                                                                                                                                                                                        QueryRowx using this statement. Any placeholder parameters are replaced with supplied args.

                                                                                                                                                                                                                                        func (*Stmt) QueryRowxContext

                                                                                                                                                                                                                                        func (s *Stmt) QueryRowxContext(ctx context.Context, args ...interface{}) *Row

                                                                                                                                                                                                                                          QueryRowxContext using this statement. Any placeholder parameters are replaced with supplied args.

                                                                                                                                                                                                                                          func (*Stmt) Queryx

                                                                                                                                                                                                                                          func (s *Stmt) Queryx(args ...interface{}) (*Rows, error)

                                                                                                                                                                                                                                            Queryx using this statement. Any placeholder parameters are replaced with supplied args.

                                                                                                                                                                                                                                            func (*Stmt) QueryxContext

                                                                                                                                                                                                                                            func (s *Stmt) QueryxContext(ctx context.Context, args ...interface{}) (*Rows, error)

                                                                                                                                                                                                                                              QueryxContext using this statement. Any placeholder parameters are replaced with supplied args.

                                                                                                                                                                                                                                              func (*Stmt) Select

                                                                                                                                                                                                                                              func (s *Stmt) Select(dest interface{}, args ...interface{}) error

                                                                                                                                                                                                                                                Select using the prepared statement. Any placeholder parameters are replaced with supplied args.

                                                                                                                                                                                                                                                func (*Stmt) SelectContext

                                                                                                                                                                                                                                                func (s *Stmt) SelectContext(ctx context.Context, dest interface{}, args ...interface{}) error

                                                                                                                                                                                                                                                  SelectContext using the prepared statement. Any placeholder parameters are replaced with supplied args.

                                                                                                                                                                                                                                                  func (*Stmt) Unsafe

                                                                                                                                                                                                                                                  func (s *Stmt) Unsafe() *Stmt

                                                                                                                                                                                                                                                    Unsafe returns a version of Stmt which will silently succeed to scan when columns in the SQL result have no fields in the destination struct.

                                                                                                                                                                                                                                                    type Tx

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

                                                                                                                                                                                                                                                      Tx is an sqlx wrapper around sql.Tx with extra functionality

                                                                                                                                                                                                                                                      func (*Tx) BindNamed

                                                                                                                                                                                                                                                      func (tx *Tx) BindNamed(query string, arg interface{}) (string, []interface{}, error)

                                                                                                                                                                                                                                                        BindNamed binds a query within a transaction's bindvar type.

                                                                                                                                                                                                                                                        func (*Tx) DriverName

                                                                                                                                                                                                                                                        func (tx *Tx) DriverName() string

                                                                                                                                                                                                                                                          DriverName returns the driverName used by the DB which began this transaction.

                                                                                                                                                                                                                                                          func (*Tx) Get

                                                                                                                                                                                                                                                          func (tx *Tx) Get(dest interface{}, query string, args ...interface{}) error

                                                                                                                                                                                                                                                            Get within a transaction. Any placeholder parameters are replaced with supplied args. An error is returned if the result set is empty.

                                                                                                                                                                                                                                                            func (*Tx) GetContext

                                                                                                                                                                                                                                                            func (tx *Tx) GetContext(ctx context.Context, dest interface{}, query string, args ...interface{}) error

                                                                                                                                                                                                                                                              GetContext within a transaction and context. Any placeholder parameters are replaced with supplied args. An error is returned if the result set is empty.

                                                                                                                                                                                                                                                              func (*Tx) MustExec

                                                                                                                                                                                                                                                              func (tx *Tx) MustExec(query string, args ...interface{}) sql.Result

                                                                                                                                                                                                                                                                MustExec runs MustExec within a transaction. Any placeholder parameters are replaced with supplied args.

                                                                                                                                                                                                                                                                func (*Tx) MustExecContext

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

                                                                                                                                                                                                                                                                  MustExecContext runs MustExecContext within a transaction. Any placeholder parameters are replaced with supplied args.

                                                                                                                                                                                                                                                                  func (*Tx) NamedExec

                                                                                                                                                                                                                                                                  func (tx *Tx) NamedExec(query string, arg interface{}) (sql.Result, error)

                                                                                                                                                                                                                                                                    NamedExec a named query within a transaction. Any named placeholder parameters are replaced with fields from arg.

                                                                                                                                                                                                                                                                    func (*Tx) NamedExecContext

                                                                                                                                                                                                                                                                    func (tx *Tx) NamedExecContext(ctx context.Context, query string, arg interface{}) (sql.Result, error)

                                                                                                                                                                                                                                                                      NamedExecContext using this Tx. Any named placeholder parameters are replaced with fields from arg.

                                                                                                                                                                                                                                                                      func (*Tx) NamedQuery

                                                                                                                                                                                                                                                                      func (tx *Tx) NamedQuery(query string, arg interface{}) (*Rows, error)

                                                                                                                                                                                                                                                                        NamedQuery within a transaction. Any named placeholder parameters are replaced with fields from arg.

                                                                                                                                                                                                                                                                        func (*Tx) NamedStmt

                                                                                                                                                                                                                                                                        func (tx *Tx) NamedStmt(stmt *NamedStmt) *NamedStmt

                                                                                                                                                                                                                                                                          NamedStmt returns a version of the prepared statement which runs within a transaction.

                                                                                                                                                                                                                                                                          func (*Tx) NamedStmtContext

                                                                                                                                                                                                                                                                          func (tx *Tx) NamedStmtContext(ctx context.Context, stmt *NamedStmt) *NamedStmt

                                                                                                                                                                                                                                                                            NamedStmtContext returns a version of the prepared statement which runs within a transaction.

                                                                                                                                                                                                                                                                            func (*Tx) PrepareNamed

                                                                                                                                                                                                                                                                            func (tx *Tx) PrepareNamed(query string) (*NamedStmt, error)

                                                                                                                                                                                                                                                                              PrepareNamed returns an sqlx.NamedStmt

                                                                                                                                                                                                                                                                              func (*Tx) PrepareNamedContext

                                                                                                                                                                                                                                                                              func (tx *Tx) PrepareNamedContext(ctx context.Context, query string) (*NamedStmt, error)

                                                                                                                                                                                                                                                                                PrepareNamedContext returns an sqlx.NamedStmt

                                                                                                                                                                                                                                                                                func (*Tx) Preparex

                                                                                                                                                                                                                                                                                func (tx *Tx) Preparex(query string) (*Stmt, error)

                                                                                                                                                                                                                                                                                  Preparex a statement within a transaction.

                                                                                                                                                                                                                                                                                  func (*Tx) PreparexContext

                                                                                                                                                                                                                                                                                  func (tx *Tx) PreparexContext(ctx context.Context, query string) (*Stmt, error)

                                                                                                                                                                                                                                                                                    PreparexContext returns an sqlx.Stmt instead of a sql.Stmt.

                                                                                                                                                                                                                                                                                    The provided context is used for the preparation of the statement, not for the execution of the statement.

                                                                                                                                                                                                                                                                                    func (*Tx) QueryRowx

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

                                                                                                                                                                                                                                                                                      QueryRowx within a transaction. Any placeholder parameters are replaced with supplied args.

                                                                                                                                                                                                                                                                                      func (*Tx) QueryRowxContext

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

                                                                                                                                                                                                                                                                                        QueryRowxContext within a transaction and context. Any placeholder parameters are replaced with supplied args.

                                                                                                                                                                                                                                                                                        func (*Tx) Queryx

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

                                                                                                                                                                                                                                                                                          Queryx within a transaction. Any placeholder parameters are replaced with supplied args.

                                                                                                                                                                                                                                                                                          func (*Tx) QueryxContext

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

                                                                                                                                                                                                                                                                                            QueryxContext within a transaction and context. Any placeholder parameters are replaced with supplied args.

                                                                                                                                                                                                                                                                                            func (*Tx) Rebind

                                                                                                                                                                                                                                                                                            func (tx *Tx) Rebind(query string) string

                                                                                                                                                                                                                                                                                              Rebind a query within a transaction's bindvar type.

                                                                                                                                                                                                                                                                                              func (*Tx) Select

                                                                                                                                                                                                                                                                                              func (tx *Tx) Select(dest interface{}, query string, args ...interface{}) error

                                                                                                                                                                                                                                                                                                Select within a transaction. Any placeholder parameters are replaced with supplied args.

                                                                                                                                                                                                                                                                                                func (*Tx) SelectContext

                                                                                                                                                                                                                                                                                                func (tx *Tx) SelectContext(ctx context.Context, dest interface{}, query string, args ...interface{}) error

                                                                                                                                                                                                                                                                                                  SelectContext within a transaction and context. Any placeholder parameters are replaced with supplied args.

                                                                                                                                                                                                                                                                                                  func (*Tx) Stmtx

                                                                                                                                                                                                                                                                                                  func (tx *Tx) Stmtx(stmt interface{}) *Stmt

                                                                                                                                                                                                                                                                                                    Stmtx returns a version of the prepared statement which runs within a transaction. Provided stmt can be either *sql.Stmt or *sqlx.Stmt.

                                                                                                                                                                                                                                                                                                    func (*Tx) StmtxContext

                                                                                                                                                                                                                                                                                                    func (tx *Tx) StmtxContext(ctx context.Context, stmt interface{}) *Stmt

                                                                                                                                                                                                                                                                                                      StmtxContext returns a version of the prepared statement which runs within a transaction. Provided stmt can be either *sql.Stmt or *sqlx.Stmt.

                                                                                                                                                                                                                                                                                                      func (*Tx) Unsafe

                                                                                                                                                                                                                                                                                                      func (tx *Tx) Unsafe() *Tx

                                                                                                                                                                                                                                                                                                        Unsafe returns a version of Tx which will silently succeed to scan when columns in the SQL result have no fields in the destination struct.

                                                                                                                                                                                                                                                                                                        Directories

                                                                                                                                                                                                                                                                                                        Path Synopsis
                                                                                                                                                                                                                                                                                                        Package reflectx implements extensions to the standard reflect lib suitable for implementing marshalling and unmarshalling packages.
                                                                                                                                                                                                                                                                                                        Package reflectx implements extensions to the standard reflect lib suitable for implementing marshalling and unmarshalling packages.