sqlitex

package
v0.1.3 Latest Latest
Warning

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

Go to latest
Published: May 8, 2019 License: ISC Imports: 12 Imported by: 0

Documentation

Overview

Package sqlitex provides utilities for working with SQLite.

Index

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

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

Types

type Buffer

type Buffer struct {
	io.Reader
	io.Writer
	io.ByteScanner
	// contains filtered or unexported fields
}

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 NewBuffer

func NewBuffer(conn *sqlite.Conn) (*Buffer, error)

NewBuffer creates a Buffer with 16KB pages.

func NewBufferSize

func NewBufferSize(conn *sqlite.Conn, pageSize int) (*Buffer, error)

NewBufferSize creates a Buffer with a specified page size.

func (*Buffer) Cap

func (bb *Buffer) Cap() (n int64)

func (*Buffer) Close

func (bb *Buffer) Close() error

func (*Buffer) Len

func (bb *Buffer) Len() (n int64)

func (*Buffer) Read

func (bb *Buffer) Read(p []byte) (n int, err error)

func (*Buffer) ReadByte

func (bb *Buffer) ReadByte() (byte, error)

func (*Buffer) Reset

func (bb *Buffer) Reset()

func (*Buffer) UnreadByte

func (bb *Buffer) UnreadByte() error

func (*Buffer) Write

func (bb *Buffer) Write(p []byte) (n int, err error)

func (*Buffer) WriteByte

func (bb *Buffer) WriteByte(c byte) error

WriteByte appends a byte to the buffer, growing it as needed.

func (*Buffer) WriteString

func (bb *Buffer) WriteString(p string) (n int, err error)

type File

type File struct {
	io.Reader
	io.Writer
	io.Seeker
	// contains filtered or unexported fields
}

File is a readable, writable, and seekable series of temporary SQLite blobs.

func NewFile

func NewFile(conn *sqlite.Conn) (*File, error)

func NewFileSize

func NewFileSize(conn *sqlite.Conn, initSize int) (*File, error)

func (*File) Cap

func (bb *File) Cap() (n int64)

func (*File) Close

func (bb *File) Close() error

func (*File) Len

func (bb *File) Len() (n int64)

func (*File) Read

func (bb *File) Read(p []byte) (n int, err error)

func (*File) Seek

func (bb *File) Seek(offset int64, whence int) (int64, error)

func (*File) Truncate

func (bb *File) Truncate(size int64) error

func (*File) Write

func (bb *File) Write(p []byte) (n int, err error)

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

func Open(uri string, flags sqlite.OpenFlags, poolSize int) (pool *Pool, err error)

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

func (*Pool) Close

func (p *Pool) Close() (err error)

Close closes all the connections in the Pool.

func (*Pool) Get

func (p *Pool) Get(ctx context.Context) *sqlite.Conn

Get gets an SQLite connection from the pool.

If no Conn is available, Get will block until one is, or until either the Pool is closed or the context expires.

The provided context is used to control the execution lifetime of the connection. See Conn.SetInterrupt for details.

func (*Pool) Put

func (p *Pool) Put(conn *sqlite.Conn)

Put puts an SQLite connection back into the Pool. A nil conn will cause Put to panic.

Jump to

Keyboard shortcuts

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