sqlitex

func Exec ¶

func Exec(conn *sqlite.Conn, query string, resultFn func(stmt *sqlite.Stmt) error, args ...interface{}) error

Exec executes an SQLite query.

For each result row, the resultFn is called. Result values can be read by resultFn using stmt.Column* methods. If resultFn returns an error then iteration ceases and Exec returns the error value.

Any args provided to Exec are bound to numbered parameters of the query using the Stmt Bind* methods. Basic reflection on args is used to map:

integers to BindInt64
floats   to BindFloat
[]byte   to BindBytes
string   to BindText
bool     to BindBool

All other kinds are printed using fmt.Sprintf("%v", v) and passed to BindText.

Exec is implemented using the Stmt prepare mechanism which allows better interactions with Go's type system and avoids pitfalls of passing a Go closure to cgo.

As Exec is implemented using Conn.Prepare, subsequent calls to Exec with the same statement will reuse the cached statement object.

Typical use:

conn := dbpool.Get()
defer dbpool.Put(conn)

if err := sqlitex.Exec(conn, "INSERT INTO t (a, b, c, d) VALUES (?, ?, ?, ?);", nil, "a1", 1, 42, 1); err != nil {
	// handle err
}

var a []string
var b []int64
fn := func(stmt *sqlite.Stmt) error {
	a = append(a, stmt.ColumnText(0))
	b = append(b, stmt.ColumnInt64(1))
	return nil
}
err := sqlitex.Exec(conn, "SELECT a, b FROM t WHERE c = ? AND d = ?;", fn, 42, 1)
if err != nil {
	// handle err
}

func ExecScript ¶

func ExecScript(conn *sqlite.Conn, queries string) (err error)

ExecScript executes a script of SQL statements.

The script is wrapped in a SAVEPOINT transaction, which is rolled back on any error.

func ExecTransient ¶

func ExecTransient(conn *sqlite.Conn, query string, resultFn func(stmt *sqlite.Stmt) error, args ...interface{}) (err error)

ExecTransient executes an SQLite query without caching the underlying query. The interface is exactly the same as Exec.

It is the spiritual equivalent of sqlite3_exec.

func InsertRandID ¶

func InsertRandID(stmt *sqlite.Stmt, param string, min, max int64) (id int64, err error)

InsertRandID executes stmt with a random value in the range [min, max) for $param.

func ResultFloat ¶

func ResultFloat(stmt *sqlite.Stmt) (float64, error)

func ResultInt ¶

func ResultInt(stmt *sqlite.Stmt) (int, error)

func ResultInt64 ¶

func ResultInt64(stmt *sqlite.Stmt) (int64, error)

func ResultText ¶

func ResultText(stmt *sqlite.Stmt) (string, error)

func Save ¶

func Save(conn *sqlite.Conn) (releaseFn func(*error))

Save creates a named SQLite transaction using SAVEPOINT.

On success Savepoint returns a releaseFn that will call either RELEASE or ROLLBACK depending on whether the parameter *error points to a nil or non-nil error. This is designed to be deferred.

Example:

func doWork(conn *sqlite.Conn) (err error) {
	defer sqlitex.Save(conn)(&err)

	// ... do work in the transaction
}

https://www.sqlite.org/lang_savepoint.html