Documentation
¶
Overview ¶
Package sqlitex provides utilities for working with SQLite.
Index ¶
- func Exec(conn *sqlite.Conn, query string, resultFn func(stmt *sqlite.Stmt) error, ...) error
- func ExecScript(conn *sqlite.Conn, queries string) (err error)
- func ExecTransient(conn *sqlite.Conn, query string, resultFn func(stmt *sqlite.Stmt) error, ...) (err error)
- func InsertRandID(stmt *sqlite.Stmt, param string, min, max int64) (id int64, err error)
- func ResultFloat(stmt *sqlite.Stmt) (float64, error)
- func ResultInt(stmt *sqlite.Stmt) (int, error)
- func ResultInt64(stmt *sqlite.Stmt) (int64, error)
- func ResultText(stmt *sqlite.Stmt) (string, error)
- func Save(conn *sqlite.Conn) (releaseFn func(*error))
- type Buffer
- func (bb *Buffer) Cap() (n int64)
- func (bb *Buffer) Close() error
- func (bb *Buffer) Len() (n int64)
- func (bb *Buffer) Read(p []byte) (n int, err error)
- func (bb *Buffer) ReadByte() (byte, error)
- func (bb *Buffer) Reset()
- func (bb *Buffer) UnreadByte() error
- func (bb *Buffer) Write(p []byte) (n int, err error)
- func (bb *Buffer) WriteByte(c byte) error
- func (bb *Buffer) WriteString(p string) (n int, err error)
- type File
- type Pool
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
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 := sqlutil.Exec(conn, "SELECT a, b FROM t WHERE c = ? AND d = ?;", fn, 42, 1)
if err != nil {
// handle err
}
func ExecScript ¶
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 ¶
InsertRandID executes stmt with a random value in the range [min, max) for $param.
func Save ¶
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
}
Types ¶
type Buffer ¶
A Buffer is a variable-sized bytes buffer backed by SQLite blobs.
The bytes are broken into pages, with the first and last pages stored in memory, and intermediate pages loaded into blobs. Unlike a single SQLite blob, a Buffer can grow beyond its initial size. The blobs are allocated in a temporary table.
A Buffer is very similar to a bytes.Buffer.
func NewBufferSize ¶
NewBufferSize creates a Buffer with a specified page size.
func (*Buffer) UnreadByte ¶
type Pool ¶
type Pool struct {
// contains filtered or unexported fields
}
Pool is a pool of SQLite connections.
It is safe for use by multiple goroutines concurrently.
Typically, a goroutine that needs to use an SQLite *Conn Gets it from the pool and defers its return:
conn := dbpool.Get(nil) defer dbpool.Put(conn)
As Get may block, a context can be used to return if a task is cancelled. In this case the Conn returned will be nil:
conn := dbpool.Get(ctx)
if conn == nil {
return context.Canceled
}
defer dbpool.Put(conn)
func Open ¶
Open opens a fixed-size pool of SQLite connections. A flags value of 0 defaults to:
SQLITE_OPEN_READWRITE SQLITE_OPEN_CREATE SQLITE_OPEN_WAL SQLITE_OPEN_URI SQLITE_OPEN_NOMUTEX
Source Files