sqlite3

func (*Backup) Close ¶

func (b *Backup) Close() error

Close finishes a backup operation.

It is safe to close a nil, zero or closed Backup.

https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupfinish

func (*Backup) PageCount ¶

func (b *Backup) PageCount() int

PageCount returns the total number of pages in the source database at the conclusion of the most recent Backup.Step.

https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backuppagecount

func (*Backup) Remaining ¶

func (b *Backup) Remaining() int

Remaining returns the number of pages still to be backed up at the conclusion of the most recent Backup.Step.

https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupremaining

func (*Backup) Step ¶

func (b *Backup) Step(nPage int) (done bool, err error)

Step copies up to nPage pages between the source and destination databases. If nPage is negative, all remaining source pages are copied.

https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupstep

func (*Blob) Close ¶

func (b *Blob) Close() error

Close closes a BLOB handle.

It is safe to close a nil, zero or closed Blob.

https://www.sqlite.org/c3ref/blob_close.html

func (*Blob) Read ¶

func (b *Blob) Read(p []byte) (n int, err error)

Read implements the io.Reader interface.

https://www.sqlite.org/c3ref/blob_read.html

func (*Blob) ReadFrom ¶

func (b *Blob) ReadFrom(r io.Reader) (n int64, err error)

ReadFrom implements the io.ReaderFrom interface.

https://www.sqlite.org/c3ref/blob_write.html

func (*Blob) Reopen ¶

func (b *Blob) Reopen(row int64) error

Reopen moves a BLOB handle to a new row of the same database table.

https://www.sqlite.org/c3ref/blob_reopen.html

func (*Blob) Seek ¶

func (b *Blob) Seek(offset int64, whence int) (int64, error)

Seek implements the io.Seeker interface.

func (*Blob) Size ¶

func (b *Blob) Size() int64

Size returns the size of the BLOB in bytes.

https://www.sqlite.org/c3ref/blob_bytes.html

func (*Blob) Write ¶

func (b *Blob) Write(p []byte) (n int, err error)

Write implements the io.Writer interface.

https://www.sqlite.org/c3ref/blob_write.html

func (*Blob) WriteTo ¶

func (b *Blob) WriteTo(w io.Writer) (n int64, err error)

WriteTo implements the io.WriterTo interface.

https://www.sqlite.org/c3ref/blob_read.html

func (*Conn) AnyCollationNeeded ¶

func (c *Conn) AnyCollationNeeded()

AnyCollationNeeded registers a fake collating function for any unknown collating sequence. The fake collating function works like BINARY.

This extension can be used to load schemas that contain one or more unknown collating sequences.

func (*Conn) Backup ¶

func (src *Conn) Backup(srcDB, dstURI string) error

Backup backs up srcDB on the src connection to the "main" database in dstURI.

Backup opens the SQLite database file dstURI, and blocks until the entire backup is complete. Use Conn.BackupInit for incremental backup.

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

func (*Conn) BackupInit ¶

func (src *Conn) BackupInit(srcDB, dstURI string) (*Backup, error)

BackupInit initializes a backup operation to copy the content of one database into another.

BackupInit opens the SQLite database file dstURI, then initializes a backup that copies the contents of srcDB on the src connection to the "main" database in dstURI.

https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupinit

func (*Conn) Begin ¶

func (c *Conn) Begin() Tx

Begin starts a deferred transaction.

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

func (*Conn) BeginExclusive ¶

func (c *Conn) BeginExclusive() (Tx, error)

BeginExclusive starts an exclusive transaction.

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

func (*Conn) BeginImmediate ¶

func (c *Conn) BeginImmediate() (Tx, error)

BeginImmediate starts an immediate transaction.

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

func (*Conn) Changes ¶

func (c *Conn) Changes() int64

Changes returns the number of rows modified, inserted or deleted by the most recently completed INSERT, UPDATE or DELETE statement on the database connection.

https://www.sqlite.org/c3ref/changes.html

func (*Conn) Close ¶

func (c *Conn) Close() error

Close closes the database connection.

If the database connection is associated with unfinalized prepared statements, open blob handles, and/or unfinished backup objects, Close will leave the database connection open and return BUSY.

It is safe to close a nil, zero or closed Conn.

https://www.sqlite.org/c3ref/close.html

func (*Conn) CreateCollation ¶

func (c *Conn) CreateCollation(name string, fn func(a, b []byte) int) error

CreateCollation defines a new collating sequence.

https://www.sqlite.org/c3ref/create_collation.html

db, err := sqlite3.Open(":memory:")
if err != nil {
	log.Fatal(err)
}
defer db.Close()

err = db.Exec(`CREATE TABLE IF NOT EXISTS words (word VARCHAR(10))`)
if err != nil {
	log.Fatal(err)
}

err = db.Exec(`INSERT INTO words (word) VALUES ('côte'), ('cote'), ('coter'), ('coté'), ('cotée'), ('côté')`)
if err != nil {
	log.Fatal(err)
}

err = db.CreateCollation("french", collate.New(language.French).Compare)
if err != nil {
	log.Fatal(err)
}

stmt, _, err := db.Prepare(`SELECT word FROM words ORDER BY word COLLATE french`)
if err != nil {
	log.Fatal(err)
}
defer stmt.Close()

for stmt.Step() {
	fmt.Println(stmt.ColumnText(0))
}
if err := stmt.Err(); err != nil {
	log.Fatal(err)
}

Output:

cote
coté
côte
côté
cotée
coter

func (*Conn) CreateFunction ¶

func (c *Conn) CreateFunction(name string, nArg int, flag FunctionFlag, fn func(ctx Context, arg ...Value)) error

CreateFunction defines a new scalar SQL function.

https://www.sqlite.org/c3ref/create_function.html

db, err := sqlite3.Open(":memory:")
if err != nil {
	log.Fatal(err)
}
defer db.Close()

err = db.Exec(`CREATE TABLE IF NOT EXISTS words (word VARCHAR(10))`)
if err != nil {
	log.Fatal(err)
}

err = db.Exec(`INSERT INTO words (word) VALUES ('côte'), ('cote'), ('coter'), ('coté'), ('cotée'), ('côté')`)
if err != nil {
	log.Fatal(err)
}

err = db.CreateFunction("upper", 1, sqlite3.DETERMINISTIC|sqlite3.INNOCUOUS, func(ctx sqlite3.Context, arg ...sqlite3.Value) {
	ctx.ResultBlob(bytes.ToUpper(arg[0].RawBlob()))
})
if err != nil {
	log.Fatal(err)
}

stmt, _, err := db.Prepare(`SELECT upper(word) FROM words`)
if err != nil {
	log.Fatal(err)
}
defer stmt.Close()

for stmt.Step() {
	fmt.Println(stmt.ColumnText(0))
}
if err := stmt.Err(); err != nil {
	log.Fatal(err)
}

Output:

COTE
COTÉ
CÔTE
CÔTÉ
COTÉE
COTER

func (*Conn) CreateWindowFunction ¶

func (c *Conn) CreateWindowFunction(name string, nArg int, flag FunctionFlag, fn func() AggregateFunction) error

CreateWindowFunction defines a new aggregate or aggregate window SQL function. If fn returns a WindowFunction, then an aggregate window function is created.

https://www.sqlite.org/c3ref/create_function.html

package main

import (
	"fmt"
	"log"
	"unicode"

	"github.com/ianatha/go-sqlite3"
	_ "github.com/ianatha/go-sqlite3/embed"
)

func main() {
	db, err := sqlite3.Open(":memory:")
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	err = db.Exec(`CREATE TABLE IF NOT EXISTS words (word VARCHAR(10))`)
	if err != nil {
		log.Fatal(err)
	}

	err = db.Exec(`INSERT INTO words (word) VALUES ('côte'), ('cote'), ('coter'), ('coté'), ('cotée'), ('côté')`)
	if err != nil {
		log.Fatal(err)
	}

	err = db.CreateWindowFunction("count_ascii", 1, sqlite3.INNOCUOUS, newASCIICounter)
	if err != nil {
		log.Fatal(err)
	}

	stmt, _, err := db.Prepare(`SELECT count_ascii(word) OVER (ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM words`)
	if err != nil {
		log.Fatal(err)
	}
	defer stmt.Close()

	for stmt.Step() {
		fmt.Println(stmt.ColumnInt(0))
	}
	if err := stmt.Err(); err != nil {
		log.Fatal(err)
	}
}

type countASCII struct{ result int }

func newASCIICounter() sqlite3.AggregateFunction {
	return &countASCII{}
}

func (f *countASCII) Value(ctx sqlite3.Context) {
	ctx.ResultInt(f.result)
}

func (f *countASCII) Step(ctx sqlite3.Context, arg ...sqlite3.Value) {
	if f.isASCII(arg[0]) {
		f.result++
	}
}

func (f *countASCII) Inverse(ctx sqlite3.Context, arg ...sqlite3.Value) {
	if f.isASCII(arg[0]) {
		f.result--
	}
}

func (f *countASCII) isASCII(arg sqlite3.Value) bool {
	if arg.Type() != sqlite3.TEXT {
		return false
	}
	for _, c := range arg.RawBlob() {
		if c > unicode.MaxASCII {
			return false
		}
	}
	return true
}

Output:

1
2
2
1
0
0

func (*Conn) Exec ¶

func (c *Conn) Exec(sql string) error

Exec is a convenience function that allows an application to run multiple statements of SQL without having to use a lot of code.

https://www.sqlite.org/c3ref/exec.html

func (*Conn) GetAutocommit ¶

func (c *Conn) GetAutocommit() bool

GetAutocommit tests the connection for auto-commit mode.

https://www.sqlite.org/c3ref/get_autocommit.html

func (*Conn) LastInsertRowID ¶

func (c *Conn) LastInsertRowID() int64

LastInsertRowID returns the rowid of the most recent successful INSERT on the database connection.

https://www.sqlite.org/c3ref/last_insert_rowid.html

func (*Conn) OpenBlob ¶

func (c *Conn) OpenBlob(db, table, column string, row int64, write bool) (*Blob, error)

OpenBlob opens a BLOB for incremental I/O.

https://www.sqlite.org/c3ref/blob_open.html

func (*Conn) Pragma ¶

func (c *Conn) Pragma(str string) ([]string, error)

Pragma executes a PRAGMA statement and returns any results.

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

func (*Conn) Prepare ¶

func (c *Conn) Prepare(sql string) (stmt *Stmt, tail string, err error)

Prepare calls Conn.PrepareFlags with no flags.

func (*Conn) PrepareFlags ¶

func (c *Conn) PrepareFlags(sql string, flags PrepareFlag) (stmt *Stmt, tail string, err error)

PrepareFlags compiles the first SQL statement in sql; tail is left pointing to what remains uncompiled. If the input text contains no SQL (if the input is an empty string or a comment), both stmt and err will be nil.

https://www.sqlite.org/c3ref/prepare.html

func (*Conn) Restore ¶

func (dst *Conn) Restore(dstDB, srcURI string) error

Restore restores dstDB on the dst connection from the "main" database in srcURI.

Restore opens the SQLite database file srcURI, and blocks until the entire restore is complete.

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

func (*Conn) Savepoint ¶

func (c *Conn) Savepoint() Savepoint

Savepoint establishes a new transaction savepoint.

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

func (*Conn) SetInterrupt ¶

func (c *Conn) SetInterrupt(ctx context.Context) (old context.Context)

SetInterrupt interrupts a long-running query when a context is done.

Subsequent uses of the connection will return INTERRUPT until the context is reset by another call to SetInterrupt.

To associate a timeout with a connection:

ctx, cancel := context.WithTimeout(context.TODO(), 100*time.Millisecond)
conn.SetInterrupt(ctx)
defer cancel()

SetInterrupt returns the old context assigned to the connection.

https://www.sqlite.org/c3ref/interrupt.html

func (Context) GetAuxData ¶

func (c Context) GetAuxData(n int) any

GetAuxData returns metadata for argument n of the function.

https://www.sqlite.org/c3ref/get_auxdata.html

func (Context) ResultBlob ¶

func (c Context) ResultBlob(value []byte)

ResultBlob sets the result of the function to a []byte. Returning a nil slice is the same as calling Context.ResultNull.

https://www.sqlite.org/c3ref/result_blob.html

func (Context) ResultBool ¶

func (c Context) ResultBool(value bool)

ResultBool sets the result of the function to a bool. SQLite does not have a separate boolean storage class. Instead, boolean values are stored as integers 0 (false) and 1 (true).

https://www.sqlite.org/c3ref/result_blob.html

func (Context) ResultError ¶

func (c Context) ResultError(err error)

ResultError sets the result of the function an error.

https://www.sqlite.org/c3ref/result_blob.html

func (Context) ResultFloat ¶

func (c Context) ResultFloat(value float64)

ResultFloat sets the result of the function to a float64.

https://www.sqlite.org/c3ref/result_blob.html

func (Context) ResultInt ¶

func (c Context) ResultInt(value int)

ResultInt sets the result of the function to an int.

https://www.sqlite.org/c3ref/result_blob.html

func (Context) ResultInt64 ¶

func (c Context) ResultInt64(value int64)

ResultInt64 sets the result of the function to an int64.

https://www.sqlite.org/c3ref/result_blob.html

func (Context) ResultNull ¶

func (c Context) ResultNull()

ResultNull sets the result of the function to NULL.

https://www.sqlite.org/c3ref/result_blob.html

func (Context) ResultText ¶

func (c Context) ResultText(value string)

ResultText sets the result of the function to a string.

https://www.sqlite.org/c3ref/result_blob.html

func (Context) ResultTime ¶

func (c Context) ResultTime(value time.Time, format TimeFormat)

ResultTime sets the result of the function to a time.Time.

https://www.sqlite.org/c3ref/result_blob.html

func (Context) ResultZeroBlob ¶

func (c Context) ResultZeroBlob(n int64)

BindZeroBlob sets the result of the function to a zero-filled, length n BLOB.

https://www.sqlite.org/c3ref/result_blob.html

func (Context) SetAuxData ¶

func (c Context) SetAuxData(n int, data any)

SetAuxData saves metadata for argument n of the function.

https://www.sqlite.org/c3ref/get_auxdata.html

db, err := sqlite3.Open(":memory:")
if err != nil {
	log.Fatal(err)
}
defer db.Close()

err = db.Exec(`CREATE TABLE IF NOT EXISTS words (word VARCHAR(10))`)
if err != nil {
	log.Fatal(err)
}

err = db.Exec(`INSERT INTO words (word) VALUES ('côte'), ('cote'), ('coter'), ('coté'), ('cotée'), ('côté')`)
if err != nil {
	log.Fatal(err)
}

err = db.CreateFunction("regexp", 2, sqlite3.DETERMINISTIC|sqlite3.INNOCUOUS, func(ctx sqlite3.Context, arg ...sqlite3.Value) {
	re, ok := ctx.GetAuxData(0).(*regexp.Regexp)
	if !ok {
		r, err := regexp.Compile(arg[0].Text())
		if err != nil {
			ctx.ResultError(err)
			return
		}
		ctx.SetAuxData(0, r)
		re = r
	}
	ctx.ResultBool(re.Match(arg[1].RawBlob()))
})
if err != nil {
	log.Fatal(err)
}

stmt, _, err := db.Prepare(`SELECT word FROM words WHERE word REGEXP '^\p{L}+e$'`)
if err != nil {
	log.Fatal(err)
}
defer stmt.Close()

for stmt.Step() {
	fmt.Println(stmt.ColumnText(0))
}
if err := stmt.Err(); err != nil {
	log.Fatal(err)
}

Output:

cote
côte
cotée

func (Datatype) String ¶

func (t Datatype) String() string

String implements the fmt.Stringer interface.

func (*Error) As ¶

func (e *Error) As(err any) bool

As converts this error to an ErrorCode or ExtendedErrorCode.

func (*Error) Code ¶

func (e *Error) Code() ErrorCode

Code returns the primary error code for this error.

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

func (*Error) Error ¶

func (e *Error) Error() string

Error implements the error interface.

func (*Error) ExtendedCode ¶

func (e *Error) ExtendedCode() ExtendedErrorCode

ExtendedCode returns the extended error code for this error.

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

func (*Error) Is ¶

func (e *Error) Is(err error) bool

Is tests whether this error matches a given ErrorCode or ExtendedErrorCode.

It makes it possible to do:

if errors.Is(err, sqlite3.BUSY) {
	// ... handle BUSY
}

func (*Error) SQL ¶

func (e *Error) SQL() string

SQL returns the SQL starting at the token that triggered a syntax error.

func (*Error) Temporary ¶

func (e *Error) Temporary() bool

Temporary returns true for BUSY errors.

func (*Error) Timeout ¶

func (e *Error) Timeout() bool

Timeout returns true for BUSY_TIMEOUT errors.

func (ErrorCode) Error ¶

func (e ErrorCode) Error() string

Error implements the error interface.

func (ErrorCode) Temporary ¶

func (e ErrorCode) Temporary() bool

Temporary returns true for BUSY errors.

func (ExtendedErrorCode) As ¶

func (e ExtendedErrorCode) As(err any) bool

As converts this error to an ErrorCode.

func (ExtendedErrorCode) Error ¶

func (e ExtendedErrorCode) Error() string

Error implements the error interface.

func (ExtendedErrorCode) Is ¶

func (e ExtendedErrorCode) Is(err error) bool

Is tests whether this error matches a given ErrorCode.

func (ExtendedErrorCode) Temporary ¶

func (e ExtendedErrorCode) Temporary() bool

Temporary returns true for BUSY errors.

func (ExtendedErrorCode) Timeout ¶

func (e ExtendedErrorCode) Timeout() bool

Timeout returns true for BUSY_TIMEOUT errors.

func (Savepoint) Release ¶

func (s Savepoint) Release(errp *error)

Release releases the savepoint rolling back any changes if *error points to a non-nil error.

This is meant to be deferred:

func doWork(conn *sqlite3.Conn) (err error) {
	savept := conn.Savepoint()
	defer savept.Release(&err)

	// ... do work in the transaction
}

func (Savepoint) Rollback ¶

func (s Savepoint) Rollback() error

Rollback rolls the transaction back to the savepoint, even if the connection has been interrupted. Rollback does not release the savepoint.

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

func (*Stmt) BindBlob ¶

func (s *Stmt) BindBlob(param int, value []byte) error

BindBlob binds a []byte to the prepared statement. The leftmost SQL parameter has an index of 1. Binding a nil slice is the same as calling Stmt.BindNull.

https://www.sqlite.org/c3ref/bind_blob.html

func (*Stmt) BindBool ¶

func (s *Stmt) BindBool(param int, value bool) error

BindBool binds a bool to the prepared statement. The leftmost SQL parameter has an index of 1. SQLite does not have a separate boolean storage class. Instead, boolean values are stored as integers 0 (false) and 1 (true).

https://www.sqlite.org/c3ref/bind_blob.html

func (*Stmt) BindCount ¶

func (s *Stmt) BindCount() int

BindCount returns the number of SQL parameters in the prepared statement.

https://www.sqlite.org/c3ref/bind_parameter_count.html

func (*Stmt) BindFloat ¶

func (s *Stmt) BindFloat(param int, value float64) error

BindFloat binds a float64 to the prepared statement. The leftmost SQL parameter has an index of 1.

https://www.sqlite.org/c3ref/bind_blob.html

func (*Stmt) BindIndex ¶

func (s *Stmt) BindIndex(name string) int

BindIndex returns the index of a parameter in the prepared statement given its name.

https://www.sqlite.org/c3ref/bind_parameter_index.html

func (*Stmt) BindInt ¶

func (s *Stmt) BindInt(param int, value int) error

BindInt binds an int to the prepared statement. The leftmost SQL parameter has an index of 1.

https://www.sqlite.org/c3ref/bind_blob.html

func (*Stmt) BindInt64 ¶

func (s *Stmt) BindInt64(param int, value int64) error

BindInt64 binds an int64 to the prepared statement. The leftmost SQL parameter has an index of 1.

https://www.sqlite.org/c3ref/bind_blob.html

func (*Stmt) BindName ¶

func (s *Stmt) BindName(param int) string

BindName returns the name of a parameter in the prepared statement. The leftmost SQL parameter has an index of 1.

https://www.sqlite.org/c3ref/bind_parameter_name.html

func (*Stmt) BindNull ¶

func (s *Stmt) BindNull(param int) error

BindNull binds a NULL to the prepared statement. The leftmost SQL parameter has an index of 1.

https://www.sqlite.org/c3ref/bind_blob.html

func (*Stmt) BindText ¶

func (s *Stmt) BindText(param int, value string) error

BindText binds a string to the prepared statement. The leftmost SQL parameter has an index of 1.

https://www.sqlite.org/c3ref/bind_blob.html

func (*Stmt) BindTime ¶

func (s *Stmt) BindTime(param int, value time.Time, format TimeFormat) error

BindTime binds a time.Time to the prepared statement. The leftmost SQL parameter has an index of 1.

https://www.sqlite.org/c3ref/bind_blob.html

func (*Stmt) BindZeroBlob ¶

func (s *Stmt) BindZeroBlob(param int, n int64) error

BindZeroBlob binds a zero-filled, length n BLOB to the prepared statement. The leftmost SQL parameter has an index of 1.

https://www.sqlite.org/c3ref/bind_blob.html

func (*Stmt) ClearBindings ¶

func (s *Stmt) ClearBindings() error

ClearBindings resets all bindings on the prepared statement.

https://www.sqlite.org/c3ref/clear_bindings.html

func (*Stmt) Close ¶

func (s *Stmt) Close() error

Close destroys the prepared statement object.

It is safe to close a nil, zero or closed Stmt.

https://www.sqlite.org/c3ref/finalize.html

func (*Stmt) ColumnBlob ¶

func (s *Stmt) ColumnBlob(col int, buf []byte) []byte

ColumnBlob appends to buf and returns the value of the result column as a []byte. The leftmost column of the result set has the index 0.

https://www.sqlite.org/c3ref/column_blob.html

func (*Stmt) ColumnBool ¶

func (s *Stmt) ColumnBool(col int) bool

ColumnBool returns the value of the result column as a bool. The leftmost column of the result set has the index 0. SQLite does not have a separate boolean storage class. Instead, boolean values are retrieved as integers, with 0 converted to false and any other value to true.

https://www.sqlite.org/c3ref/column_blob.html

func (*Stmt) ColumnCount ¶

func (s *Stmt) ColumnCount() int

ColumnCount returns the number of columns in a result set.

https://www.sqlite.org/c3ref/column_count.html

func (*Stmt) ColumnFloat ¶

func (s *Stmt) ColumnFloat(col int) float64

ColumnFloat returns the value of the result column as a float64. The leftmost column of the result set has the index 0.

https://www.sqlite.org/c3ref/column_blob.html

func (*Stmt) ColumnInt ¶

func (s *Stmt) ColumnInt(col int) int

ColumnInt returns the value of the result column as an int. The leftmost column of the result set has the index 0.

https://www.sqlite.org/c3ref/column_blob.html

func (*Stmt) ColumnInt64 ¶

func (s *Stmt) ColumnInt64(col int) int64

ColumnInt64 returns the value of the result column as an int64. The leftmost column of the result set has the index 0.

https://www.sqlite.org/c3ref/column_blob.html

func (*Stmt) ColumnName ¶

func (s *Stmt) ColumnName(col int) string

ColumnName returns the name of the result column. The leftmost column of the result set has the index 0.

https://www.sqlite.org/c3ref/column_name.html

func (*Stmt) ColumnRawBlob ¶

func (s *Stmt) ColumnRawBlob(col int) []byte

ColumnRawBlob returns the value of the result column as a []byte. The []byte is owned by SQLite and may be invalidated by subsequent calls to Stmt methods. The leftmost column of the result set has the index 0.

https://www.sqlite.org/c3ref/column_blob.html

func (*Stmt) ColumnRawText ¶

func (s *Stmt) ColumnRawText(col int) []byte

ColumnRawText returns the value of the result column as a []byte. The []byte is owned by SQLite and may be invalidated by subsequent calls to Stmt methods. The leftmost column of the result set has the index 0.

https://www.sqlite.org/c3ref/column_blob.html

func (*Stmt) ColumnText ¶

func (s *Stmt) ColumnText(col int) string

ColumnText returns the value of the result column as a string. The leftmost column of the result set has the index 0.

https://www.sqlite.org/c3ref/column_blob.html

func (*Stmt) ColumnTime ¶

func (s *Stmt) ColumnTime(col int, format TimeFormat) time.Time

ColumnTime returns the value of the result column as a time.Time. The leftmost column of the result set has the index 0.

https://www.sqlite.org/c3ref/column_blob.html

func (*Stmt) ColumnType ¶

func (s *Stmt) ColumnType(col int) Datatype

ColumnType returns the initial Datatype of the result column. The leftmost column of the result set has the index 0.

https://www.sqlite.org/c3ref/column_blob.html

func (*Stmt) Err ¶

func (s *Stmt) Err() error

Err gets the last error occurred during Stmt.Step. Err returns nil after Stmt.Reset is called.

https://www.sqlite.org/c3ref/step.html

func (*Stmt) Exec ¶

func (s *Stmt) Exec() error

Exec is a convenience function that repeatedly calls Stmt.Step until it returns false, then calls Stmt.Reset to reset the statement and get any error that occurred.

func (*Stmt) Reset ¶

func (s *Stmt) Reset() error

Reset resets the prepared statement object.

https://www.sqlite.org/c3ref/reset.html

func (*Stmt) Step ¶

func (s *Stmt) Step() bool

Step evaluates the SQL statement. If the SQL statement being executed returns any data, then true is returned each time a new row of data is ready for processing by the caller. The values may be accessed using the Column access functions. Step is called again to retrieve the next row of data. If an error has occurred, Step returns false; call Stmt.Err or Stmt.Reset to get the error.

https://www.sqlite.org/c3ref/step.html

func (TimeFormat) Decode ¶

func (f TimeFormat) Decode(v any) (time.Time, error)

Decode decodes a time value using this format.

The time value can be a string, an int64, or a float64.

Formats TimeFormat8 through TimeFormat10 (and TimeFormat8TZ through TimeFormat10TZ) assume a date of 2000-01-01.

The timezone indicator and fractional seconds are always optional for formats TimeFormat2 through TimeFormat10 (and TimeFormat2TZ through TimeFormat10TZ).

TimeFormatAuto implements (and extends) the SQLite auto modifier. Julian day numbers are safe to use for historical dates, from 4712BC through 9999AD. Unix timestamps (expressed in seconds, milliseconds, microseconds, or nanoseconds) are safe to use for current events, from at least 1980 through at least 2260. Unix timestamps before 1980 and after 9999 may be misinterpreted as julian day numbers, or have the wrong time unit.

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

func (TimeFormat) Encode ¶

func (f TimeFormat) Encode(t time.Time) any

Encode encodes a time value using this format.

TimeFormatDefault and TimeFormatAuto encode using time.RFC3339Nano, with nanosecond accuracy, and preserving any timezone offset.

This is the format used by the database/sql driver: database/sql.Row.Scan will decode as time.Time values encoded with time.RFC3339Nano.

Time values encoded with time.RFC3339Nano cannot be sorted as strings to produce a time-ordered sequence.

Assuming that the time zones of the time values are the same (e.g., all in UTC), and expressed using the same string (e.g., all "Z" or all "+00:00"), use the TIME collating sequence to produce a time-ordered sequence.

Otherwise, use TimeFormat7 for time-ordered encoding.

Formats TimeFormat1 through TimeFormat10 convert time values to UTC before encoding.

Returns a string for the text formats, a float64 for TimeFormatJulianDay and TimeFormatUnixFrac, or an int64 for the other numeric formats.

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

func (Tx) Commit ¶

func (tx Tx) Commit() error

Commit commits the transaction.

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

func (Tx) End ¶

func (tx Tx) End(errp *error)

End calls either Tx.Commit or Tx.Rollback depending on whether *error points to a nil or non-nil error.

This is meant to be deferred:

func doWork(conn *sqlite3.Conn) (err error) {
	tx := conn.Begin()
	defer tx.End(&err)

	// ... do work in the transaction
}

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

func (Tx) Rollback ¶

func (tx Tx) Rollback() error

Rollback rolls back the transaction, even if the connection has been interrupted.

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

func (Value) Blob ¶

func (v Value) Blob(buf []byte) []byte

Blob appends to buf and returns the value as a []byte.

https://www.sqlite.org/c3ref/value_blob.html

func (Value) Bool ¶

func (v Value) Bool() bool

Bool returns the value as a bool. SQLite does not have a separate boolean storage class. Instead, boolean values are retrieved as integers, with 0 converted to false and any other value to true.

https://www.sqlite.org/c3ref/value_blob.html

func (Value) Float ¶

func (v Value) Float() float64

Float returns the value as a float64.

https://www.sqlite.org/c3ref/value_blob.html

func (Value) Int ¶

func (v Value) Int() int

Int returns the value as an int.

https://www.sqlite.org/c3ref/value_blob.html

func (Value) Int64 ¶

func (v Value) Int64() int64

Int64 returns the value as an int64.

https://www.sqlite.org/c3ref/value_blob.html

func (Value) RawBlob ¶

func (v Value) RawBlob() []byte

RawBlob returns the value as a []byte. The []byte is owned by SQLite and may be invalidated by subsequent calls to Value methods.

https://www.sqlite.org/c3ref/value_blob.html

func (Value) RawText ¶

func (v Value) RawText() []byte

RawText returns the value as a []byte. The []byte is owned by SQLite and may be invalidated by subsequent calls to Value methods.

https://www.sqlite.org/c3ref/value_blob.html

func (Value) Text ¶

func (v Value) Text() string

Text returns the value as a string.

https://www.sqlite.org/c3ref/value_blob.html

func (Value) Time ¶

func (v Value) Time(format TimeFormat) time.Time

Time returns the value as a time.Time.

https://www.sqlite.org/c3ref/value_blob.html

func (Value) Type ¶

func (v Value) Type() Datatype

Type returns the initial Datatype of the value.

https://www.sqlite.org/c3ref/value_blob.html