package sqlite3

Import Path
	github.com/ncruces/go-sqlite3 (on go.dev)

Dependency Relation
	imports 25 packages, and imported by 3 packages

Involved Source Files

	    backup.go
	    blob.go
	    config.go
	    conn.go
	    const.go
	    context.go
	    error.go
	    func.go
	    json.go
	    pointer.go
	    quote.go
	    registry.go
	  d sqlite.go
		Package sqlite3 wraps the C SQLite API.

	    stmt.go
	    time.go
	    txn.go
	    value.go
	    vtab.go
Code Examples

	
		package main
		
		import (
			"fmt"
			"log"
		
			"github.com/ncruces/go-sqlite3"
			_ "github.com/ncruces/go-sqlite3/embed"
		)
		
		const memory = ":memory:"
		
		func main() {
			db, err := sqlite3.Open(memory)
			if err != nil {
				log.Fatal(err)
			}
		
			err = db.Exec(`CREATE TABLE users (id INT, name VARCHAR(10))`)
			if err != nil {
				log.Fatal(err)
			}
		
			err = db.Exec(`INSERT INTO users (id, name) VALUES (0, 'go'), (1, 'zig'), (2, 'whatever')`)
			if err != nil {
				log.Fatal(err)
			}
		
			stmt, _, err := db.Prepare(`SELECT id, name FROM users`)
			if err != nil {
				log.Fatal(err)
			}
			defer stmt.Close()
		
			for stmt.Step() {
				fmt.Println(stmt.ColumnInt(0), stmt.ColumnText(1))
			}
			if err := stmt.Err(); err != nil {
				log.Fatal(err)
			}
		
			err = stmt.Close()
			if err != nil {
				log.Fatal(err)
			}
		
			err = db.Close()
			if err != nil {
				log.Fatal(err)
			}
		}


Package-Level Type Names (total 52)

	/* sort by: alphabet | popularity */
	 type AggregateConstructor (func)
		AggregateConstructor is a an [AggregateFunction] constructor.

		As Inputs Of (at least one exported)
			func (*Conn).CreateWindowFunction(name string, nArg int, flag FunctionFlag, fn AggregateConstructor) error

	 type AggregateFunction (interface)
		AggregateFunction is the interface an aggregate function should implement.
		
		https://sqlite.org/appfunc.html

		Methods (total 2)
			( AggregateFunction) Step(ctx Context, arg ...Value)
				Step is invoked to add a row to the current window.
				The function arguments, if any, corresponding to the row being added, are passed to Step.
				Implementations must not retain arg.

			( AggregateFunction) Value(ctx Context)
				Value is invoked to return the current (or final) value of the aggregate.

		Implemented By (at least one exported)
			 WindowFunction (interface)

	 type AggregateSeqFunction (func)
		AggregateSeqFunction is the type of an aggregate SQL function.
		Implementations must not retain the slices yielded by seq.

		As Inputs Of (at least one exported)
			func (*Conn).CreateAggregateFunction(name string, nArg int, flag FunctionFlag, fn AggregateSeqFunction) error

	 type AuthorizerActionCode uint32 (basic type)
		AuthorizerActionCode are the integer action codes
		that the authorizer callback may be passed.
		
		https://sqlite.org/c3ref/c_alter_table.html

		As Types Of (total 33)
			const AUTH_ALTER_TABLE
			const AUTH_ANALYZE
			const AUTH_ATTACH
			const AUTH_CREATE_INDEX
			const AUTH_CREATE_TABLE
			const AUTH_CREATE_TEMP_INDEX
			const AUTH_CREATE_TEMP_TABLE
			const AUTH_CREATE_TEMP_TRIGGER
			const AUTH_CREATE_TEMP_VIEW
			const AUTH_CREATE_TRIGGER
			const AUTH_CREATE_VIEW
			const AUTH_CREATE_VTABLE
			const AUTH_DELETE
			const AUTH_DETACH
			const AUTH_DROP_INDEX
			const AUTH_DROP_TABLE
			const AUTH_DROP_TEMP_INDEX
			const AUTH_DROP_TEMP_TABLE
			const AUTH_DROP_TEMP_TRIGGER
			const AUTH_DROP_TEMP_VIEW
			const AUTH_DROP_TRIGGER
			const AUTH_DROP_VIEW
			const AUTH_DROP_VTABLE
			const AUTH_FUNCTION
			const AUTH_INSERT
			const AUTH_PRAGMA
			const AUTH_READ
			const AUTH_RECURSIVE
			const AUTH_REINDEX
			const AUTH_SAVEPOINT
			const AUTH_SELECT
			const AUTH_TRANSACTION
			const AUTH_UPDATE

	 type AuthorizerReturnCode uint32 (basic type)
		AuthorizerReturnCode are the integer codes
		that the authorizer callback may return.
		
		https://sqlite.org/c3ref/c_deny.html

		As Types Of (total 3)
			const AUTH_DENY
			const AUTH_IGNORE
			const AUTH_OK

	 type Backup (struct)
		Backup is an handle to an ongoing online backup operation.
		
		https://sqlite.org/c3ref/backup.html

		Methods (total 4)
			(*Backup) Close() error
				Close finishes a backup operation.
				
				It is safe to close a nil, zero or closed Backup.
				
				https://sqlite.org/c3ref/backup_finish.html#sqlite3backupfinish

			(*Backup) PageCount() int
				PageCount returns the total number of pages in the source database
				at the conclusion of the most recent [Backup.Step].
				
				https://sqlite.org/c3ref/backup_finish.html#sqlite3backuppagecount

			(*Backup) Remaining() int
				Remaining returns the number of pages still to be backed up
				at the conclusion of the most recent [Backup.Step].
				
				https://sqlite.org/c3ref/backup_finish.html#sqlite3backupremaining

			(*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://sqlite.org/c3ref/backup_finish.html#sqlite3backupstep

		Implements (at least 2)
			*Backup : github.com/prometheus/common/expfmt.Closer
			*Backup : io.Closer
		As Outputs Of (at least one exported)
			func (*Conn).BackupInit(srcDB, dstURI string) (*Backup, error)

	 type Blob (struct)
		Blob is an handle to an open BLOB.
		
		It implements [io.ReadWriteSeeker] for incremental BLOB I/O.
		
		https://sqlite.org/c3ref/blob.html

		Methods (total 8)
			(*Blob) Close() error
				Close closes a BLOB handle.
				
				It is safe to close a nil, zero or closed Blob.
				
				https://sqlite.org/c3ref/blob_close.html

			(*Blob) Read(p []byte) (n int, err error)
				Read implements the [io.Reader] interface.
				
				https://sqlite.org/c3ref/blob_read.html

			(*Blob) ReadFrom(r io.Reader) (n int64, err error)
				ReadFrom implements the [io.ReaderFrom] interface.
				
				https://sqlite.org/c3ref/blob_write.html

			(*Blob) Reopen(row int64) error
				Reopen moves a BLOB handle to a new row of the same database table.
				
				https://sqlite.org/c3ref/blob_reopen.html

			(*Blob) Seek(offset int64, whence int) (int64, error)
				Seek implements the [io.Seeker] interface.

			(*Blob) Size() int64
				Size returns the size of the BLOB in bytes.
				
				https://sqlite.org/c3ref/blob_bytes.html

			(*Blob) Write(p []byte) (n int, err error)
				Write implements the [io.Writer] interface.
				
				https://sqlite.org/c3ref/blob_write.html

			(*Blob) WriteTo(w io.Writer) (n int64, err error)
				WriteTo implements the [io.WriterTo] interface.
				
				https://sqlite.org/c3ref/blob_read.html

		Implements (at least 20)
			*Blob : github.com/gobwas/ws.HandshakeHeader
			*Blob : github.com/miekg/dns.Writer
			*Blob : github.com/pion/stun.Connection
			*Blob : github.com/pion/stun/v3.Connection
			*Blob : github.com/prometheus/common/expfmt.Closer
			*Blob : internal/bisect.Writer
			*Blob : io.Closer
			*Blob : io.ReadCloser
			*Blob : io.Reader
			*Blob : io.ReaderFrom
			*Blob : io.ReadSeekCloser
			*Blob : io.ReadSeeker
			*Blob : io.ReadWriteCloser
			*Blob : io.ReadWriter
			*Blob : io.ReadWriteSeeker
			*Blob : io.Seeker
			*Blob : io.WriteCloser
			*Blob : io.Writer
			*Blob : io.WriterTo
			*Blob : io.WriteSeeker
		As Outputs Of (at least one exported)
			func (*Conn).OpenBlob(db, table, column string, row int64, write bool) (*Blob, error)

	 type CheckpointMode uint32 (basic type)
		CheckpointMode are all the checkpoint mode values.
		
		https://sqlite.org/c3ref/c_checkpoint_full.html

		As Inputs Of (at least one exported)
			func (*Conn).WALCheckpoint(schema string, mode CheckpointMode) (nLog, nCkpt int, err error)
		As Types Of (total 4)
			const CHECKPOINT_FULL
			const CHECKPOINT_PASSIVE
			const CHECKPOINT_RESTART
			const CHECKPOINT_TRUNCATE

	 type CollatingFunction (func)
		CollatingFunction is the type of a collation callback.
		Implementations must not retain a or b.

		As Inputs Of (at least one exported)
			func (*Conn).CreateCollation(name string, fn CollatingFunction) error

	 type Conn (struct)
		Conn is a database connection handle.
		A Conn is not safe for concurrent use by multiple goroutines.
		
		https://sqlite.org/c3ref/sqlite3.html

		Methods (total 58)
			( Conn) AnyCollationNeeded() error
				AnyCollationNeeded uses [Conn.CollationNeeded] to register
				a fake collating function for any unknown collating sequence.
				The fake collating function works like BINARY.
				
				This can be used to load schemas that contain
				one or more unknown collating sequences.

			(*Conn) AutoVacuumPages(cb func(schema string, dbPages, freePages, bytesPerPage uint) uint) error
				AutoVacuumPages registers a autovacuum compaction amount callback.
				
				https://sqlite.org/c3ref/autovacuum_pages.html

			(*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://sqlite.org/backup.html

			(*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://sqlite.org/c3ref/backup_finish.html#sqlite3backupinit

			(*Conn) Begin() Txn
				Begin starts a deferred transaction.
				It panics if a transaction is in-progress.
				For nested transactions, use [Conn.Savepoint].
				
				https://sqlite.org/lang_transaction.html

			(*Conn) BeginConcurrent() (Txn, error)
				BeginConcurrent starts a concurrent transaction.
				
				Experimental: requires a custom build of SQLite.
				
				https://sqlite.org/cgi/src/doc/begin-concurrent/doc/begin_concurrent.md

			(*Conn) BeginExclusive() (Txn, error)
				BeginExclusive starts an exclusive transaction.
				
				https://sqlite.org/lang_transaction.html

			(*Conn) BeginImmediate() (Txn, error)
				BeginImmediate starts an immediate transaction.
				
				https://sqlite.org/lang_transaction.html

			(*Conn) BusyHandler(cb func(ctx context.Context, count int) (retry bool)) error
				BusyHandler registers a callback to handle [BUSY] errors.
				
				https://sqlite.org/c3ref/busy_handler.html

			(*Conn) BusyTimeout(timeout time.Duration) error
				BusyTimeout sets a busy timeout.
				
				https://sqlite.org/c3ref/busy_timeout.html

			(*Conn) CacheFlush() error
				CacheFlush flushes caches to disk mid-transaction.
				
				https://sqlite.org/c3ref/db_cacheflush.html

			(*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://sqlite.org/c3ref/changes.html

			(*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://sqlite.org/c3ref/close.html

			(*Conn) CollationNeeded(cb func(db *Conn, name string)) error
				CollationNeeded registers a callback to be invoked
				whenever an unknown collation sequence is required.
				
				https://sqlite.org/c3ref/collation_needed.html

			(*Conn) CommitHook(cb func() (ok bool))
				CommitHook registers a callback function to be invoked
				whenever a transaction is committed.
				Return true to allow the commit operation to continue normally.
				
				https://sqlite.org/c3ref/commit_hook.html

			(*Conn) Config(op DBConfig, arg ...bool) (bool, error)
				Config makes configuration changes to a database connection.
				Only boolean configuration options are supported.
				Called with no arg reads the current configuration value,
				called with one arg sets and returns the new value.
				
				https://sqlite.org/c3ref/db_config.html

			(*Conn) ConfigLog(cb func(code ExtendedErrorCode, msg string)) error
				ConfigLog sets up the error logging callback for the connection.
				
				https://sqlite.org/errlog.html

			(*Conn) CreateAggregateFunction(name string, nArg int, flag FunctionFlag, fn AggregateSeqFunction) error
				CreateAggregateFunction defines a new aggregate SQL function.
				
				https://sqlite.org/c3ref/create_function.html

			(*Conn) CreateCollation(name string, fn CollatingFunction) error
				CreateCollation defines a new collating sequence.
				
				https://sqlite.org/c3ref/create_collation.html

			(*Conn) CreateFunction(name string, nArg int, flag FunctionFlag, fn ScalarFunction) error
				CreateFunction defines a new scalar SQL function.
				
				https://sqlite.org/c3ref/create_function.html

			(*Conn) CreateWindowFunction(name string, nArg int, flag FunctionFlag, fn AggregateConstructor) error
				CreateWindowFunction defines a new aggregate or aggregate window SQL function.
				If fn returns a [WindowFunction], an aggregate window function is created.
				If fn returns an [io.Closer], it will be called to free resources.
				
				https://sqlite.org/c3ref/create_function.html

			(*Conn) DBName(n int) string
				DBName returns the schema name for n-th database on the database connection.
				
				https://sqlite.org/c3ref/db_name.html

			(*Conn) DeclareVTab(sql string) error
				DeclareVTab declares the schema of a virtual table.
				
				https://sqlite.org/c3ref/declare_vtab.html

			(*Conn) EnableChecksums(schema string) error
				EnableChecksums enables checksums on a database.
				
				https://sqlite.org/cksumvfs.html

			(*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://sqlite.org/c3ref/exec.html

			(*Conn) FileControl(schema string, op FcntlOpcode, arg ...any) (any, error)
				FileControl allows low-level control of database files.
				Only a subset of opcodes are supported.
				
				https://sqlite.org/c3ref/file_control.html

			(*Conn) Filename(schema string) *vfs.Filename
				Filename returns the filename for a database.
				
				https://sqlite.org/c3ref/db_filename.html

			(*Conn) GetAutocommit() bool
				GetAutocommit tests the connection for auto-commit mode.
				
				https://sqlite.org/c3ref/get_autocommit.html

			(*Conn) GetInterrupt() context.Context
				GetInterrupt gets the context set with [Conn.SetInterrupt].

			(*Conn) HardHeapLimit(n int64) int64
				HardHeapLimit imposes a hard limit on heap size.
				
				https://sqlite.org/c3ref/hard_heap_limit64.html

			(*Conn) LastInsertRowID() int64
				LastInsertRowID returns the rowid of the most recent successful INSERT
				on the database connection.
				
				https://sqlite.org/c3ref/last_insert_rowid.html

			(*Conn) Limit(id LimitCategory, value int) int
				Limit allows the size of various constructs to be
				limited on a connection by connection basis.
				
				https://sqlite.org/c3ref/limit.html

			(*Conn) Log(code ExtendedErrorCode, format string, a ...any)
				Log writes a message into the error log established by [Conn.ConfigLog].
				
				https://sqlite.org/c3ref/log.html

			(*Conn) OpenBlob(db, table, column string, row int64, write bool) (*Blob, error)
				OpenBlob opens a BLOB for incremental I/O.
				
				https://sqlite.org/c3ref/blob_open.html

			(*Conn) OverloadFunction(name string, nArg int) error
				OverloadFunction overloads a function for a virtual table.
				
				https://sqlite.org/c3ref/overload_function.html

			(*Conn) Prepare(sql string) (stmt *Stmt, tail string, err error)
				Prepare calls [Conn.PrepareFlags] with no flags.

			(*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://sqlite.org/c3ref/prepare.html

			(*Conn) ReadOnly(schema string) (ro bool, ok bool)
				ReadOnly determines if a database is read-only.
				
				https://sqlite.org/c3ref/db_readonly.html

			(*Conn) ReleaseMemory() error
				ReleaseMemory frees memory used by a database connection.
				
				https://sqlite.org/c3ref/db_release_memory.html

			(*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://sqlite.org/backup.html

			(*Conn) RollbackHook(cb func())
				RollbackHook registers a callback function to be invoked
				whenever a transaction is rolled back.
				
				https://sqlite.org/c3ref/commit_hook.html

			(*Conn) Savepoint() Savepoint
				Savepoint establishes a new transaction savepoint.
				
				https://sqlite.org/lang_savepoint.html

			(*Conn) SetAuthorizer(cb func(action AuthorizerActionCode, name3rd, name4th, schema, inner string) AuthorizerReturnCode) error
				SetAuthorizer registers an authorizer callback with the database connection.
				
				https://sqlite.org/c3ref/set_authorizer.html

			(*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://sqlite.org/c3ref/interrupt.html

			(*Conn) SetLastInsertRowID(id int64)
				SetLastInsertRowID allows the application to set the value returned by
				[Conn.LastInsertRowID].
				
				https://sqlite.org/c3ref/set_last_insert_rowid.html

			(*Conn) SoftHeapLimit(n int64) int64
				SoftHeapLimit imposes a soft limit on heap size.
				
				https://sqlite.org/c3ref/hard_heap_limit64.html

			(*Conn) Status(op DBStatus, reset bool) (current, highwater int, err error)
				Status retrieves runtime status information about a database connection.
				
				https://sqlite.org/c3ref/db_status.html

			(*Conn) Stmts() iter.Seq[*Stmt]
				Stmts returns an iterator for the prepared statements
				associated with the database connection.
				
				https://sqlite.org/c3ref/next_stmt.html

			(*Conn) TableColumnMetadata(schema, table, column string) (declType, collSeq string, notNull, primaryKey, autoInc bool, err error)
				TableColumnMetadata extracts metadata about a column of a table.
				
				https://sqlite.org/c3ref/table_column_metadata.html

			(*Conn) TotalChanges() int64
				TotalChanges returns the number of rows modified, inserted or deleted
				by all INSERT, UPDATE or DELETE statements completed
				since the database connection was opened.
				
				https://sqlite.org/c3ref/total_changes.html

			(*Conn) Trace(mask TraceEvent, cb func(evt TraceEvent, arg1 any, arg2 any) error) error
				Trace registers a trace callback function against the database connection.
				
				https://sqlite.org/c3ref/trace_v2.html

			(*Conn) TxnState(schema string) TxnState
				TxnState determines the transaction state of a database.
				
				https://sqlite.org/c3ref/txn_state.html

			(*Conn) UpdateHook(cb func(action AuthorizerActionCode, schema, table string, rowid int64))
				UpdateHook registers a callback function to be invoked
				whenever a row is updated, inserted or deleted in a rowid table.
				
				https://sqlite.org/c3ref/update_hook.html

			(*Conn) VTabConfig(op VTabConfigOption, args ...any) error
				VTabConfig configures various facets of the virtual table interface.
				
				https://sqlite.org/c3ref/vtab_config.html

			(*Conn) VTabOnConflict() VTabConflictMode
				VTabOnConflict determines the virtual table conflict policy.
				
				https://sqlite.org/c3ref/vtab_on_conflict.html

			(*Conn) WALAutoCheckpoint(pages int) error
				WALAutoCheckpoint configures WAL auto-checkpoints.
				
				https://sqlite.org/c3ref/wal_autocheckpoint.html

			(*Conn) WALCheckpoint(schema string, mode CheckpointMode) (nLog, nCkpt int, err error)
				WALCheckpoint checkpoints a WAL database.
				
				https://sqlite.org/c3ref/wal_checkpoint_v2.html

			(*Conn) WALHook(cb func(db *Conn, schema string, pages int) error)
				WALHook registers a callback function to be invoked
				each time data is committed to a database in WAL mode.
				
				https://sqlite.org/c3ref/wal_hook.html

		Implements (at least 2)
			*Conn : github.com/prometheus/common/expfmt.Closer
			*Conn : io.Closer
		As Outputs Of (at least 6)
			func Open(filename string) (*Conn, error)
			func OpenContext(ctx context.Context, filename string) (*Conn, error)
			func OpenFlags(filename string, flags OpenFlag) (*Conn, error)
			func Context.Conn() *Conn
			func (*Stmt).Conn() *Conn
			func github.com/ncruces/go-sqlite3/driver.Conn.Raw() *Conn
		As Inputs Of (at least one exported)
			func CreateModule[T](db *Conn, name string, create, connect VTabConstructor[T]) error

	 type Context (struct)
		Context is the context in which an SQL function executes.
		An SQLite [Context] is in no way related to a Go [context.Context].
		
		https://sqlite.org/c3ref/context.html

		Methods (total 19)
			( Context) Conn() *Conn
				Conn returns the database connection of the
				[Conn.CreateFunction] or [Conn.CreateWindowFunction]
				routines that originally registered the application defined function.
				
				https://sqlite.org/c3ref/context_db_handle.html

			( Context) GetAuxData(n int) any
				GetAuxData returns metadata for argument n of the function.
				
				https://sqlite.org/c3ref/get_auxdata.html

			( Context) ResultBlob(value []byte)
				ResultBlob sets the result of the function to a []byte.
				
				https://sqlite.org/c3ref/result_blob.html

			( 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://sqlite.org/c3ref/result_blob.html

			( Context) ResultError(err error)
				ResultError sets the result of the function an error.
				
				https://sqlite.org/c3ref/result_blob.html

			( Context) ResultFloat(value float64)
				ResultFloat sets the result of the function to a float64.
				
				https://sqlite.org/c3ref/result_blob.html

			( Context) ResultInt(value int)
				ResultInt sets the result of the function to an int.
				
				https://sqlite.org/c3ref/result_blob.html

			( Context) ResultInt64(value int64)
				ResultInt64 sets the result of the function to an int64.
				
				https://sqlite.org/c3ref/result_blob.html

			( Context) ResultJSON(value any)
				ResultJSON sets the result of the function to the JSON encoding of value.
				
				https://sqlite.org/c3ref/result_blob.html

			( Context) ResultNull()
				ResultNull sets the result of the function to NULL.
				
				https://sqlite.org/c3ref/result_blob.html

			( Context) ResultPointer(ptr any)
				ResultPointer sets the result of the function to NULL, just like [Context.ResultNull],
				except that it also associates ptr with that NULL value such that it can be retrieved
				within an application-defined SQL function using [Value.Pointer].
				
				https://sqlite.org/c3ref/result_blob.html

			( Context) ResultRawText(value []byte)
				ResultRawText sets the text result of the function to a []byte.
				
				https://sqlite.org/c3ref/result_blob.html

			( Context) ResultSubtype(t uint)
				ResultSubtype sets the subtype of the result of the function.
				
				https://sqlite.org/c3ref/result_subtype.html

			( Context) ResultText(value string)
				ResultText sets the result of the function to a string.
				
				https://sqlite.org/c3ref/result_blob.html

			( Context) ResultTime(value time.Time, format TimeFormat)
				ResultTime sets the result of the function to a [time.Time].
				
				https://sqlite.org/c3ref/result_blob.html

			( Context) ResultValue(value Value)
				ResultValue sets the result of the function to a copy of [Value].
				
				https://sqlite.org/c3ref/result_blob.html

			( Context) ResultZeroBlob(n int64)
				ResultZeroBlob sets the result of the function to a zero-filled, length n BLOB.
				
				https://sqlite.org/c3ref/result_blob.html

			( Context) SetAuxData(n int, data any)
				SetAuxData saves metadata for argument n of the function.
				
				https://sqlite.org/c3ref/get_auxdata.html

			( Context) VTabNoChange() bool
				VTabNoChange may return true if a column is being fetched as part
				of an update during which the column value will not change.
				
				https://sqlite.org/c3ref/vtab_nochange.html

		As Inputs Of (at least 6)
			func AggregateFunction.Step(ctx Context, arg ...Value)
			func AggregateFunction.Value(ctx Context)
			func VTabCursor.Column(ctx Context, n int) error
			func WindowFunction.Inverse(ctx Context, arg ...Value)
			func WindowFunction.Step(ctx Context, arg ...Value)
			func WindowFunction.Value(ctx Context)

	 type Datatype uint32 (basic type)
		Datatype is a fundamental datatype of SQLite.
		
		https://sqlite.org/c3ref/c_blob.html

		Methods (only one)
			( Datatype) String() string
				String implements the [fmt.Stringer] interface.

		Implements (at least 2)
			 Datatype : expvar.Var
			 Datatype : fmt.Stringer
		As Outputs Of (at least 3)
			func (*Stmt).ColumnType(col int) Datatype
			func Value.NumericType() Datatype
			func Value.Type() Datatype
		As Types Of (total 5)
			const BLOB
			const FLOAT
			const INTEGER
			const NULL
			const TEXT

	 type DBConfig uint32 (basic type)
		DBConfig are the available database connection configuration options.
		
		https://sqlite.org/c3ref/c_dbconfig_defensive.html

		As Inputs Of (at least one exported)
			func (*Conn).Config(op DBConfig, arg ...bool) (bool, error)
		As Types Of (total 21)
			const DBCONFIG_DEFENSIVE
			const DBCONFIG_DQS_DDL
			const DBCONFIG_DQS_DML
			const DBCONFIG_ENABLE_ATTACH_CREATE
			const DBCONFIG_ENABLE_ATTACH_WRITE
			const DBCONFIG_ENABLE_COMMENTS
			const DBCONFIG_ENABLE_FKEY
			const DBCONFIG_ENABLE_FTS3_TOKENIZER
			const DBCONFIG_ENABLE_LOAD_EXTENSION
			const DBCONFIG_ENABLE_QPSG
			const DBCONFIG_ENABLE_TRIGGER
			const DBCONFIG_ENABLE_VIEW
			const DBCONFIG_LEGACY_ALTER_TABLE
			const DBCONFIG_LEGACY_FILE_FORMAT
			const DBCONFIG_NO_CKPT_ON_CLOSE
			const DBCONFIG_RESET_DATABASE
			const DBCONFIG_REVERSE_SCANORDER
			const DBCONFIG_STMT_SCANSTATUS
			const DBCONFIG_TRIGGER_EQP
			const DBCONFIG_TRUSTED_SCHEMA
			const DBCONFIG_WRITABLE_SCHEMA

	 type DBStatus uint32 (basic type)
		DBStatus are the available "verbs" that can be passed to the [Conn.Status] method.
		
		https://sqlite.org/c3ref/c_dbstatus_options.html

		As Inputs Of (at least one exported)
			func (*Conn).Status(op DBStatus, reset bool) (current, highwater int, err error)
		As Types Of (total 13)
			const DBSTATUS_CACHE_HIT
			const DBSTATUS_CACHE_MISS
			const DBSTATUS_CACHE_SPILL
			const DBSTATUS_CACHE_USED
			const DBSTATUS_CACHE_USED_SHARED
			const DBSTATUS_CACHE_WRITE
			const DBSTATUS_DEFERRED_FKS
			const DBSTATUS_LOOKASIDE_HIT
			const DBSTATUS_LOOKASIDE_MISS_FULL
			const DBSTATUS_LOOKASIDE_MISS_SIZE
			const DBSTATUS_LOOKASIDE_USED
			const DBSTATUS_SCHEMA_USED
			const DBSTATUS_STMT_USED

	 type Error (struct)
		Error wraps an SQLite Error Code.
		
		https://sqlite.org/c3ref/errcode.html

		Methods (total 8)
			(*Error) As(err any) bool
				As converts this error to an [ErrorCode] or [ExtendedErrorCode].

			(*Error) Code() ErrorCode
				Code returns the primary error code for this error.
				
				https://sqlite.org/rescode.html

			(*Error) Error() string
				Error implements the error interface.

			(*Error) ExtendedCode() ExtendedErrorCode
				ExtendedCode returns the extended error code for this error.
				
				https://sqlite.org/rescode.html

			(*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
					}

			(*Error) SQL() string
				SQL returns the SQL starting at the token that triggered a syntax error.

			(*Error) Temporary() bool
				Temporary returns true for [BUSY] errors.

			(*Error) Timeout() bool
				Timeout returns true for [BUSY_TIMEOUT] errors.

		Implements (at least 3)
			*Error : github.com/jbenet/go-temp-err-catcher.Temporary
			*Error : error
			*Error : net.Error

	 type ErrorCode uint8 (basic type)
		ErrorCode is a result code that [Error.Code] might return.
		
		https://sqlite.org/rescode.html

		Methods (total 3)
			( ErrorCode) Error() string
				Error implements the error interface.

			( ErrorCode) ExtendedCode() ExtendedErrorCode
				ExtendedCode returns the extended error code for this error.

			( ErrorCode) Temporary() bool
				Temporary returns true for [BUSY] errors.

		Implements (at least 2)
			 ErrorCode : github.com/jbenet/go-temp-err-catcher.Temporary
			 ErrorCode : error
		As Outputs Of (at least 2)
			func (*Error).Code() ErrorCode
			func ExtendedErrorCode.Code() ErrorCode
		As Types Of (total 28)
			const ABORT
			const AUTH
			const BUSY
			const CANTOPEN
			const CONSTRAINT
			const CORRUPT
			const EMPTY
			const ERROR
			const FORMAT
			const FULL
			const INTERNAL
			const INTERRUPT
			const IOERR
			const LOCKED
			const MISMATCH
			const MISUSE
			const NOLFS
			const NOMEM
			const NOTADB
			const NOTFOUND
			const NOTICE
			const PERM
			const PROTOCOL
			const RANGE
			const READONLY
			const SCHEMA
			const TOOBIG
			const WARNING

	 type ExtendedErrorCode uint16 (basic type)
		ExtendedErrorCode is a result code that [Error.ExtendedCode] might return.
		
		https://sqlite.org/rescode.html

		Methods (total 6)
			( ExtendedErrorCode) As(err any) bool
				As converts this error to an [ErrorCode].

			( ExtendedErrorCode) Code() ErrorCode
				Code returns the primary error code for this error.

			( ExtendedErrorCode) Error() string
				Error implements the error interface.

			( ExtendedErrorCode) Is(err error) bool
				Is tests whether this error matches a given [ErrorCode].

			( ExtendedErrorCode) Temporary() bool
				Temporary returns true for [BUSY] errors.

			( ExtendedErrorCode) Timeout() bool
				Timeout returns true for [BUSY_TIMEOUT] errors.

		Implements (at least 3)
			 ExtendedErrorCode : github.com/jbenet/go-temp-err-catcher.Temporary
			 ExtendedErrorCode : error
			 ExtendedErrorCode : net.Error
		As Outputs Of (at least 2)
			func (*Error).ExtendedCode() ExtendedErrorCode
			func ErrorCode.ExtendedCode() ExtendedErrorCode
		As Inputs Of (at least one exported)
			func (*Conn).Log(code ExtendedErrorCode, format string, a ...any)
		As Types Of (total 74)
			const ABORT_ROLLBACK
			const AUTH_USER
			const BUSY_RECOVERY
			const BUSY_SNAPSHOT
			const BUSY_TIMEOUT
			const CANTOPEN_CONVPATH
			const CANTOPEN_FULLPATH
			const CANTOPEN_ISDIR
			const CANTOPEN_NOTEMPDIR
			const CANTOPEN_SYMLINK
			const CONSTRAINT_CHECK
			const CONSTRAINT_COMMITHOOK
			const CONSTRAINT_DATATYPE
			const CONSTRAINT_FOREIGNKEY
			const CONSTRAINT_FUNCTION
			const CONSTRAINT_NOTNULL
			const CONSTRAINT_PINNED
			const CONSTRAINT_PRIMARYKEY
			const CONSTRAINT_ROWID
			const CONSTRAINT_TRIGGER
			const CONSTRAINT_UNIQUE
			const CONSTRAINT_VTAB
			const CORRUPT_INDEX
			const CORRUPT_SEQUENCE
			const CORRUPT_VTAB
			const ERROR_MISSING_COLLSEQ
			const ERROR_RETRY
			const ERROR_SNAPSHOT
			const IOERR_ACCESS
			const IOERR_AUTH
			const IOERR_BEGIN_ATOMIC
			const IOERR_BLOCKED
			const IOERR_CHECKRESERVEDLOCK
			const IOERR_CLOSE
			const IOERR_COMMIT_ATOMIC
			const IOERR_CONVPATH
			const IOERR_CORRUPTFS
			const IOERR_DATA
			const IOERR_DELETE
			const IOERR_DELETE_NOENT
			const IOERR_DIR_CLOSE
			const IOERR_DIR_FSYNC
			const IOERR_FSTAT
			const IOERR_FSYNC
			const IOERR_GETTEMPPATH
			const IOERR_IN_PAGE
			const IOERR_LOCK
			const IOERR_MMAP
			const IOERR_NOMEM
			const IOERR_RDLOCK
			const IOERR_READ
			const IOERR_ROLLBACK_ATOMIC
			const IOERR_SEEK
			const IOERR_SHMLOCK
			const IOERR_SHMMAP
			const IOERR_SHMOPEN
			const IOERR_SHMSIZE
			const IOERR_SHORT_READ
			const IOERR_TRUNCATE
			const IOERR_UNLOCK
			const IOERR_VNODE
			const IOERR_WRITE
			const LOCKED_SHAREDCACHE
			const LOCKED_VTAB
			const NOTICE_RBU
			const NOTICE_RECOVER_ROLLBACK
			const NOTICE_RECOVER_WAL
			const READONLY_CANTINIT
			const READONLY_CANTLOCK
			const READONLY_DBMOVED
			const READONLY_DIRECTORY
			const READONLY_RECOVERY
			const READONLY_ROLLBACK
			const WARNING_AUTOINDEX

	 type FcntlOpcode uint32 (basic type)
		FcntlOpcode are the available opcodes for [Conn.FileControl].
		
		https://sqlite.org/c3ref/c_fcntl_begin_atomic_write.html

		As Inputs Of (at least one exported)
			func (*Conn).FileControl(schema string, op FcntlOpcode, arg ...any) (any, error)
		As Types Of (total 11)
			const FCNTL_CHUNK_SIZE
			const FCNTL_DATA_VERSION
			const FCNTL_FILE_POINTER
			const FCNTL_JOURNAL_POINTER
			const FCNTL_LOCKSTATE
			const FCNTL_NULL_IO
			const FCNTL_PERSIST_WAL
			const FCNTL_POWERSAFE_OVERWRITE
			const FCNTL_RESERVE_BYTES
			const FCNTL_RESET_CACHE
			const FCNTL_VFS_POINTER

	 type FunctionFlag uint32 (basic type)
		FunctionFlag is a flag that can be passed to
		[Conn.CreateFunction] and [Conn.CreateWindowFunction].
		
		https://sqlite.org/c3ref/c_deterministic.html

		As Inputs Of (at least 3)
			func (*Conn).CreateAggregateFunction(name string, nArg int, flag FunctionFlag, fn AggregateSeqFunction) error
			func (*Conn).CreateFunction(name string, nArg int, flag FunctionFlag, fn ScalarFunction) error
			func (*Conn).CreateWindowFunction(name string, nArg int, flag FunctionFlag, fn AggregateConstructor) error
		As Types Of (total 6)
			const DETERMINISTIC
			const DIRECTONLY
			const INNOCUOUS
			const RESULT_SUBTYPE
			const SELFORDER1
			const SUBTYPE

	 type IndexConstraint (struct)
		An IndexConstraint describes virtual table indexing constraint information.
		
		https://sqlite.org/c3ref/index_info.html

		Fields (total 3)
			Column int
			Op IndexConstraintOp
			Usable bool

	 type IndexConstraintOp uint8 (basic type)
		IndexConstraintOp is a virtual table constraint operator code.
		
		https://sqlite.org/c3ref/c_index_constraint_eq.html

		As Outputs Of (at least one exported)
			func VTabOverloader.FindFunction(arg int, name string) (ScalarFunction, IndexConstraintOp)
		As Types Of (total 17)
			const INDEX_CONSTRAINT_EQ
			const INDEX_CONSTRAINT_FUNCTION
			const INDEX_CONSTRAINT_GE
			const INDEX_CONSTRAINT_GLOB
			const INDEX_CONSTRAINT_GT
			const INDEX_CONSTRAINT_IS
			const INDEX_CONSTRAINT_ISNOT
			const INDEX_CONSTRAINT_ISNOTNULL
			const INDEX_CONSTRAINT_ISNULL
			const INDEX_CONSTRAINT_LE
			const INDEX_CONSTRAINT_LIKE
			const INDEX_CONSTRAINT_LIMIT
			const INDEX_CONSTRAINT_LT
			const INDEX_CONSTRAINT_MATCH
			const INDEX_CONSTRAINT_NE
			const INDEX_CONSTRAINT_OFFSET
			const INDEX_CONSTRAINT_REGEXP

	 type IndexConstraintUsage (struct)
		An IndexConstraintUsage describes how virtual table indexing constraints will be used.
		
		https://sqlite.org/c3ref/index_info.html

		Fields (total 2)
			ArgvIndex int
			Omit bool

	 type IndexInfo (struct)
		An IndexInfo describes virtual table indexing information.
		
		https://sqlite.org/c3ref/index_info.html

		Fields (total 10)
			ColumnsUsed uint64
			Constraint []IndexConstraint
				Inputs

			ConstraintUsage []IndexConstraintUsage
				Outputs

			EstimatedCost float64
			EstimatedRows int64
			IdxFlags IndexScanFlag
			IdxNum int
			IdxStr string
			OrderBy []IndexOrderBy
			OrderByConsumed bool
		Methods (total 4)
			(*IndexInfo) Collation(column int) string
				Collation returns the name of the collation for a virtual table constraint.
				
				https://sqlite.org/c3ref/vtab_collation.html

			(*IndexInfo) Distinct() int
				Distinct determines if a virtual table query is DISTINCT.
				
				https://sqlite.org/c3ref/vtab_distinct.html

			(*IndexInfo) In(column, handle int) bool
				In identifies and handles IN constraints.
				
				https://sqlite.org/c3ref/vtab_in.html

			(*IndexInfo) RHSValue(column int) (Value, error)
				RHSValue returns the value of the right-hand operand of a constraint
				if the right-hand operand is known.
				
				https://sqlite.org/c3ref/vtab_rhs_value.html

		As Inputs Of (at least 9)
			func VTab.BestIndex(*IndexInfo) error
			func VTabChecker.BestIndex(*IndexInfo) error
			func VTabDestroyer.BestIndex(*IndexInfo) error
			func VTabOverloader.BestIndex(*IndexInfo) error
			func VTabRenamer.BestIndex(*IndexInfo) error
			func VTabSavepointer.BestIndex(*IndexInfo) error
			func VTabShadowTabler.BestIndex(*IndexInfo) error
			func VTabTxn.BestIndex(*IndexInfo) error
			func VTabUpdater.BestIndex(*IndexInfo) error

	 type IndexOrderBy (struct)
		An IndexOrderBy describes virtual table indexing order by information.
		
		https://sqlite.org/c3ref/index_info.html

		Fields (total 2)
			Column int
			Desc bool

	 type IndexScanFlag uint32 (basic type)
		IndexScanFlag is a virtual table scan flag.
		
		https://sqlite.org/c3ref/c_index_scan_unique.html

		As Types Of (only one)
			const INDEX_SCAN_UNIQUE

	 type LimitCategory uint32 (basic type)
		LimitCategory are the available run-time limit categories.
		
		https://sqlite.org/c3ref/c_limit_attached.html

		As Inputs Of (at least one exported)
			func (*Conn).Limit(id LimitCategory, value int) int
		As Types Of (total 12)
			const LIMIT_ATTACHED
			const LIMIT_COLUMN
			const LIMIT_COMPOUND_SELECT
			const LIMIT_EXPR_DEPTH
			const LIMIT_FUNCTION_ARG
			const LIMIT_LENGTH
			const LIMIT_LIKE_PATTERN_LENGTH
			const LIMIT_SQL_LENGTH
			const LIMIT_TRIGGER_DEPTH
			const LIMIT_VARIABLE_NUMBER
			const LIMIT_VDBE_OP
			const LIMIT_WORKER_THREADS

	 type OpenFlag uint32 (basic type)
		OpenFlag is a flag for the [OpenFlags] function.
		
		https://sqlite.org/c3ref/c_open_autoproxy.html

		As Inputs Of (at least one exported)
			func OpenFlags(filename string, flags OpenFlag) (*Conn, error)
		As Types Of (total 11)
			const OPEN_CREATE
			const OPEN_EXRESCODE
			const OPEN_FULLMUTEX
			const OPEN_MEMORY
			const OPEN_NOFOLLOW
			const OPEN_NOMUTEX
			const OPEN_PRIVATECACHE
			const OPEN_READONLY
			const OPEN_READWRITE
			const OPEN_SHAREDCACHE
			const OPEN_URI

	 type PrepareFlag uint32 (basic type)
		PrepareFlag is a flag that can be passed to [Conn.PrepareFlags].
		
		https://sqlite.org/c3ref/c_prepare_normalize.html

		As Inputs Of (at least one exported)
			func (*Conn).PrepareFlags(sql string, flags PrepareFlag) (stmt *Stmt, tail string, err error)
		As Types Of (total 4)
			const PREPARE_DONT_LOG
			const PREPARE_NO_VTAB
			const PREPARE_NORMALIZE
			const PREPARE_PERSISTENT

	 type Savepoint (struct)
		Savepoint is a marker within a transaction
		that allows for partial rollback.
		
		https://sqlite.org/lang_savepoint.html

		Methods (total 2)
			( 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(db *sqlite3.Conn) (err error) {
						savept := db.Savepoint()
						defer savept.Release(&err)
				
						// ... do work in the transaction
					}

			( 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://sqlite.org/lang_transaction.html

		As Outputs Of (at least 2)
			func (*Conn).Savepoint() Savepoint
			func github.com/ncruces/go-sqlite3/driver.Savepoint(tx *sql.Tx) Savepoint

	 type ScalarFunction (func)
		ScalarFunction is the type of a scalar SQL function.
		Implementations must not retain arg.

		As Outputs Of (at least one exported)
			func VTabOverloader.FindFunction(arg int, name string) (ScalarFunction, IndexConstraintOp)
		As Inputs Of (at least one exported)
			func (*Conn).CreateFunction(name string, nArg int, flag FunctionFlag, fn ScalarFunction) error

	 type Stmt (struct)
		Stmt is a prepared statement object.
		
		https://sqlite.org/c3ref/stmt.html

		Methods (total 49)
			(*Stmt) BindBlob(param int, value []byte) error
				BindBlob binds a []byte to the prepared statement.
				The leftmost SQL parameter has an index of 1.
				
				https://sqlite.org/c3ref/bind_blob.html

			(*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://sqlite.org/c3ref/bind_blob.html

			(*Stmt) BindCount() int
				BindCount returns the number of SQL parameters in the prepared statement.
				
				https://sqlite.org/c3ref/bind_parameter_count.html

			(*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://sqlite.org/c3ref/bind_blob.html

			(*Stmt) BindIndex(name string) int
				BindIndex returns the index of a parameter in the prepared statement
				given its name.
				
				https://sqlite.org/c3ref/bind_parameter_index.html

			(*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://sqlite.org/c3ref/bind_blob.html

			(*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://sqlite.org/c3ref/bind_blob.html

			(*Stmt) BindJSON(param int, value any) error
				BindJSON binds the JSON encoding of value to the prepared statement.
				The leftmost SQL parameter has an index of 1.
				
				https://sqlite.org/c3ref/bind_blob.html

			(*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://sqlite.org/c3ref/bind_parameter_name.html

			(*Stmt) BindNull(param int) error
				BindNull binds a NULL to the prepared statement.
				The leftmost SQL parameter has an index of 1.
				
				https://sqlite.org/c3ref/bind_blob.html

			(*Stmt) BindPointer(param int, ptr any) error
				BindPointer binds a NULL to the prepared statement, just like [Stmt.BindNull],
				but it also associates ptr with that NULL value such that it can be retrieved
				within an application-defined SQL function using [Value.Pointer].
				The leftmost SQL parameter has an index of 1.
				
				https://sqlite.org/c3ref/bind_blob.html

			(*Stmt) BindRawText(param int, value []byte) error
				BindRawText binds a []byte to the prepared statement as text.
				The leftmost SQL parameter has an index of 1.
				
				https://sqlite.org/c3ref/bind_blob.html

			(*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://sqlite.org/c3ref/bind_blob.html

			(*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://sqlite.org/c3ref/bind_blob.html

			(*Stmt) BindValue(param int, value Value) error
				BindValue binds a copy of value to the prepared statement.
				The leftmost SQL parameter has an index of 1.
				
				https://sqlite.org/c3ref/bind_blob.html

			(*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://sqlite.org/c3ref/bind_blob.html

			(*Stmt) Busy() bool
				Busy determines if a prepared statement has been reset.
				
				https://sqlite.org/c3ref/stmt_busy.html

			(*Stmt) ClearBindings() error
				ClearBindings resets all bindings on the prepared statement.
				
				https://sqlite.org/c3ref/clear_bindings.html

			(*Stmt) Close() error
				Close destroys the prepared statement object.
				
				It is safe to close a nil, zero or closed Stmt.
				
				https://sqlite.org/c3ref/finalize.html

			(*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://sqlite.org/c3ref/column_blob.html

			(*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 numbers,
				with 0 converted to false and any other value to true.
				
				https://sqlite.org/c3ref/column_blob.html

			(*Stmt) ColumnCount() int
				ColumnCount returns the number of columns in a result set.
				
				https://sqlite.org/c3ref/column_count.html

			(*Stmt) ColumnDatabaseName(col int) string
				ColumnDatabaseName returns the name of the database
				that is the origin of a particular result column.
				The leftmost column of the result set has the index 0.
				
				https://sqlite.org/c3ref/column_database_name.html

			(*Stmt) ColumnDeclType(col int) string
				ColumnDeclType returns the declared datatype of the result column.
				The leftmost column of the result set has the index 0.
				
				https://sqlite.org/c3ref/column_decltype.html

			(*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://sqlite.org/c3ref/column_blob.html

			(*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://sqlite.org/c3ref/column_blob.html

			(*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://sqlite.org/c3ref/column_blob.html

			(*Stmt) ColumnJSON(col int, ptr any) error
				ColumnJSON parses the JSON-encoded value of the result column
				and stores it in the value pointed to by ptr.
				The leftmost column of the result set has the index 0.
				
				https://sqlite.org/c3ref/column_blob.html

			(*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://sqlite.org/c3ref/column_name.html

			(*Stmt) ColumnOriginName(col int) string
				ColumnOriginName returns the name of the table column
				that is the origin of a particular result column.
				The leftmost column of the result set has the index 0.
				
				https://sqlite.org/c3ref/column_database_name.html

			(*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://sqlite.org/c3ref/column_blob.html

			(*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://sqlite.org/c3ref/column_blob.html

			(*Stmt) ColumnTableName(col int) string
				ColumnTableName returns the name of the table
				that is the origin of a particular result column.
				The leftmost column of the result set has the index 0.
				
				https://sqlite.org/c3ref/column_database_name.html

			(*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://sqlite.org/c3ref/column_blob.html

			(*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://sqlite.org/c3ref/column_blob.html

			(*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://sqlite.org/c3ref/column_blob.html

			(*Stmt) ColumnValue(col int) Value
				ColumnValue returns the unprotected value of the result column.
				The leftmost column of the result set has the index 0.
				
				https://sqlite.org/c3ref/column_blob.html

			(*Stmt) Columns(dest ...any) error
				Columns populates result columns into the provided slice.
				The slice must have [Stmt.ColumnCount] length.
				
				[INTEGER] columns will be retrieved as int64 values,
				[FLOAT] as float64, [NULL] as nil,
				[TEXT] as string, and [BLOB] as []byte.

			(*Stmt) ColumnsRaw(dest ...any) error
				ColumnsRaw populates result columns into the provided slice.
				The slice must have [Stmt.ColumnCount] length.
				
				[INTEGER] columns will be retrieved as int64 values,
				[FLOAT] as float64, [NULL] as nil,
				[TEXT] and [BLOB] as []byte.
				Any []byte are owned by SQLite and may be invalidated by
				subsequent calls to [Stmt] methods.

			(*Stmt) Conn() *Conn
				Conn returns the database connection to which the prepared statement belongs.
				
				https://sqlite.org/c3ref/db_handle.html

			(*Stmt) DataCount() int
				DataCount resets the number of columns in a result set.
				
				https://sqlite.org/c3ref/data_count.html

			(*Stmt) Err() error
				Err gets the last error occurred during [Stmt.Step].
				Err returns nil after [Stmt.Reset] is called.
				
				https://sqlite.org/c3ref/step.html

			(*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.

			(*Stmt) ExpandedSQL() string
				ExpandedSQL returns the SQL text of the prepared statement
				with bound parameters expanded.
				
				https://sqlite.org/c3ref/expanded_sql.html

			(*Stmt) ReadOnly() bool
				ReadOnly returns true if and only if the statement
				makes no direct changes to the content of the database file.
				
				https://sqlite.org/c3ref/stmt_readonly.html

			(*Stmt) Reset() error
				Reset resets the prepared statement object.
				
				https://sqlite.org/c3ref/reset.html

			(*Stmt) SQL() string
				SQL returns the SQL text used to create the prepared statement.
				
				https://sqlite.org/c3ref/expanded_sql.html

			(*Stmt) Status(op StmtStatus, reset bool) int
				Status monitors the performance characteristics of prepared statements.
				
				https://sqlite.org/c3ref/stmt_status.html

			(*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://sqlite.org/c3ref/step.html

		Implements (at least 2)
			*Stmt : github.com/prometheus/common/expfmt.Closer
			*Stmt : io.Closer
		As Outputs Of (at least 2)
			func (*Conn).Prepare(sql string) (stmt *Stmt, tail string, err error)
			func (*Conn).PrepareFlags(sql string, flags PrepareFlag) (stmt *Stmt, tail string, err error)

	 type StmtStatus uint32 (basic type)
		StmtStatus name counter values associated with the [Stmt.Status] method.
		
		https://sqlite.org/c3ref/c_stmtstatus_counter.html

		As Inputs Of (at least one exported)
			func (*Stmt).Status(op StmtStatus, reset bool) int
		As Types Of (total 9)
			const STMTSTATUS_AUTOINDEX
			const STMTSTATUS_FILTER_HIT
			const STMTSTATUS_FILTER_MISS
			const STMTSTATUS_FULLSCAN_STEP
			const STMTSTATUS_MEMUSED
			const STMTSTATUS_REPREPARE
			const STMTSTATUS_RUN
			const STMTSTATUS_SORT
			const STMTSTATUS_VM_STEP

	 type TimeFormat string (basic type)
		TimeFormat specifies how to encode/decode time values.
		
		See the documentation for the [TimeFormatDefault] constant
		for formats recognized by SQLite.
		
		https://sqlite.org/lang_datefunc.html

		Methods (total 3)
			( 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://sqlite.org/lang_datefunc.html

			( 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://sqlite.org/lang_datefunc.html

			( TimeFormat) Scanner(dest *time.Time) interface{Scan(any) error}
				Scanner returns a [database/sql.Scanner] that can be used as an argument to
				[database/sql.Row.Scan] and similar methods to
				decode a time value into dest using this format.

		As Inputs Of (at least 4)
			func Context.ResultTime(value time.Time, format TimeFormat)
			func (*Stmt).BindTime(param int, value time.Time, format TimeFormat) error
			func (*Stmt).ColumnTime(col int, format TimeFormat) time.Time
			func Value.Time(format TimeFormat) time.Time
		As Types Of (total 27)
			const TimeFormat1
			const TimeFormat10
			const TimeFormat10TZ
			const TimeFormat2
			const TimeFormat2TZ
			const TimeFormat3
			const TimeFormat3TZ
			const TimeFormat4
			const TimeFormat4TZ
			const TimeFormat5
			const TimeFormat5TZ
			const TimeFormat6
			const TimeFormat6TZ
			const TimeFormat7
			const TimeFormat7TZ
			const TimeFormat8
			const TimeFormat8TZ
			const TimeFormat9
			const TimeFormat9TZ
			const TimeFormatAuto
			const TimeFormatDefault
			const TimeFormatJulianDay
			const TimeFormatUnix
			const TimeFormatUnixFrac
			const TimeFormatUnixMicro
			const TimeFormatUnixMilli
			const TimeFormatUnixNano

	 type TraceEvent uint32 (basic type)
		TraceEvent identify classes of events that can be monitored with [Conn.Trace].
		
		https://sqlite.org/c3ref/c_trace.html

		As Inputs Of (at least one exported)
			func (*Conn).Trace(mask TraceEvent, cb func(evt TraceEvent, arg1 any, arg2 any) error) error
		As Types Of (total 4)
			const TRACE_CLOSE
			const TRACE_PROFILE
			const TRACE_ROW
			const TRACE_STMT

	 type Txn (struct)
		Txn is an in-progress database transaction.
		
		https://sqlite.org/lang_transaction.html

		Methods (total 3)
			( Txn) Commit() error
				Commit commits the transaction.
				
				https://sqlite.org/lang_transaction.html

			( Txn) End(errp *error)
				End calls either [Txn.Commit] or [Txn.Rollback]
				depending on whether *error points to a nil or non-nil error.
				
				This is meant to be deferred:
				
					func doWork(db *sqlite3.Conn) (err error) {
						tx := db.Begin()
						defer tx.End(&err)
				
						// ... do work in the transaction
					}
				
				https://sqlite.org/lang_transaction.html

			( Txn) Rollback() error
				Rollback rolls back the transaction,
				even if the connection has been interrupted.
				
				https://sqlite.org/lang_transaction.html

		Implements (at least 2)
			 Txn : database/sql/driver.Tx
			 Txn : gorm.io/gorm.TxCommitter
		As Outputs Of (at least 4)
			func (*Conn).Begin() Txn
			func (*Conn).BeginConcurrent() (Txn, error)
			func (*Conn).BeginExclusive() (Txn, error)
			func (*Conn).BeginImmediate() (Txn, error)

	 type TxnState uint32 (basic type)
		TxnState are the allowed return values from [Conn.TxnState].
		
		https://sqlite.org/c3ref/c_txn_none.html

		As Outputs Of (at least one exported)
			func (*Conn).TxnState(schema string) TxnState
		As Types Of (total 3)
			const TXN_NONE
			const TXN_READ
			const TXN_WRITE

	 type Value (struct)
		Value is any value that can be stored in a database table.
		
		https://sqlite.org/c3ref/value.html

		Methods (total 20)
			( Value) Blob(buf []byte) []byte
				Blob appends to buf and returns
				the value as a []byte.
				
				https://sqlite.org/c3ref/value_blob.html

			( 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 numbers,
				with 0 converted to false and any other value to true.
				
				https://sqlite.org/c3ref/value_blob.html

			(*Value) Close() error
				Close frees an SQL value previously obtained by [Value.Dup].
				
				https://sqlite.org/c3ref/value_dup.html

			( Value) Dup() *Value
				Dup makes a copy of the SQL value and returns a pointer to that copy.
				
				https://sqlite.org/c3ref/value_dup.html

			( Value) Float() float64
				Float returns the value as a float64.
				
				https://sqlite.org/c3ref/value_blob.html

			( Value) FromBind() bool
				FromBind returns true if value originated from a bound parameter.
				
				https://sqlite.org/c3ref/value_blob.html

			( Value) InFirst() (Value, error)
				InFirst returns the first element
				on the right-hand side of an IN constraint.
				
				https://sqlite.org/c3ref/vtab_in_first.html

			( Value) InNext() (Value, error)
				InNext returns the next element
				on the right-hand side of an IN constraint.
				
				https://sqlite.org/c3ref/vtab_in_first.html

			( Value) Int() int
				Int returns the value as an int.
				
				https://sqlite.org/c3ref/value_blob.html

			( Value) Int64() int64
				Int64 returns the value as an int64.
				
				https://sqlite.org/c3ref/value_blob.html

			( Value) JSON(ptr any) error
				JSON parses a JSON-encoded value
				and stores the result in the value pointed to by ptr.

			( Value) NoChange() bool
				NoChange returns true if and only if the value is unchanged
				in a virtual table update operatiom.
				
				https://sqlite.org/c3ref/value_blob.html

			( Value) NumericType() Datatype
				NumericType returns the numeric datatype of the value.
				
				https://sqlite.org/c3ref/value_blob.html

			( Value) Pointer() any
				Pointer gets the pointer associated with this value,
				or nil if it has no associated pointer.

			( 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://sqlite.org/c3ref/value_blob.html

			( 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://sqlite.org/c3ref/value_blob.html

			( Value) Subtype() uint
				Subtype returns the subtype of the value.
				
				https://sqlite.org/c3ref/value_subtype.html

			( Value) Text() string
				Text returns the value as a string.
				
				https://sqlite.org/c3ref/value_blob.html

			( Value) Time(format TimeFormat) time.Time
				Time returns the value as a [time.Time].
				
				https://sqlite.org/c3ref/value_blob.html

			( Value) Type() Datatype
				Type returns the initial datatype of the value.
				
				https://sqlite.org/c3ref/value_blob.html

		Implements (at least 2)
			*Value : github.com/prometheus/common/expfmt.Closer
			*Value : io.Closer
		As Outputs Of (at least 5)
			func (*IndexInfo).RHSValue(column int) (Value, error)
			func (*Stmt).ColumnValue(col int) Value
			func Value.Dup() *Value
			func Value.InFirst() (Value, error)
			func Value.InNext() (Value, error)
		As Inputs Of (at least 7)
			func AggregateFunction.Step(ctx Context, arg ...Value)
			func Context.ResultValue(value Value)
			func (*Stmt).BindValue(param int, value Value) error
			func VTabCursor.Filter(idxNum int, idxStr string, arg ...Value) error
			func VTabUpdater.Update(arg ...Value) (rowid int64, err error)
			func WindowFunction.Inverse(ctx Context, arg ...Value)
			func WindowFunction.Step(ctx Context, arg ...Value)

	 type VTab (interface)
		A VTab describes a particular instance of the virtual table.
		A VTab may optionally implement [io.Closer] to free resources.
		
		https://sqlite.org/c3ref/vtab.html

		Methods (total 2)
			( VTab) BestIndex(*IndexInfo) error
				https://sqlite.org/vtab.html#xbestindex

			( VTab) Open() (VTabCursor, error)
				https://sqlite.org/vtab.html#xopen

		Implemented By (at least 8)
			 VTabChecker (interface)
			 VTabDestroyer (interface)
			 VTabOverloader (interface)
			 VTabRenamer (interface)
			 VTabSavepointer (interface)
			 VTabShadowTabler (interface)
			 VTabTxn (interface)
			 VTabUpdater (interface)

	 type VTabChecker (interface)
		A VTabChecker allows a virtual table to report errors
		to the PRAGMA integrity_check and PRAGMA quick_check commands.
		
		Integrity should return an error if it finds problems in the content of the virtual table,
		but should avoid returning a (wrapped) [Error], [ErrorCode] or [ExtendedErrorCode],
		as those indicate the Integrity method itself encountered problems
		while trying to evaluate the virtual table content.

		Methods (total 3)
			( VTabChecker) BestIndex(*IndexInfo) error
				https://sqlite.org/vtab.html#xbestindex

			( VTabChecker) Integrity(schema, table string, flags int) error
				https://sqlite.org/vtab.html#xintegrity

			( VTabChecker) Open() (VTabCursor, error)
				https://sqlite.org/vtab.html#xopen

		Implements (at least one exported)
			 VTabChecker : VTab

	 type VTabConfigOption uint8 (basic type)
		VTabConfigOption is a virtual table configuration option.
		
		https://sqlite.org/c3ref/c_vtab_constraint_support.html

		As Inputs Of (at least one exported)
			func (*Conn).VTabConfig(op VTabConfigOption, args ...any) error
		As Types Of (total 4)
			const VTAB_CONSTRAINT_SUPPORT
			const VTAB_DIRECTONLY
			const VTAB_INNOCUOUS
			const VTAB_USES_ALL_SCHEMAS

	 type VTabConflictMode uint8 (basic type)
		VTabConflictMode is a virtual table conflict resolution mode.
		
		https://sqlite.org/c3ref/c_fail.html

		As Outputs Of (at least one exported)
			func (*Conn).VTabOnConflict() VTabConflictMode
		As Types Of (total 5)
			const VTAB_ABORT
			const VTAB_FAIL
			const VTAB_IGNORE
			const VTAB_REPLACE
			const VTAB_ROLLBACK

	 type VTabConstructor[T] (func)

		Type Parameters:
			T: VTab

		VTabConstructor is a virtual table constructor function.

		As Inputs Of (at least one exported)
			func CreateModule[T](db *Conn, name string, create, connect VTabConstructor[T]) error

	 type VTabCursor (interface)
		A VTabCursor describes cursors that point
		into the virtual table and are used
		to loop through the virtual table.
		A VTabCursor may optionally implement
		[io.Closer] to free resources.
		Implementations of Filter must not retain arg.
		
		https://sqlite.org/c3ref/vtab_cursor.html

		Methods (total 5)
			( VTabCursor) Column(ctx Context, n int) error
				https://sqlite.org/vtab.html#xcolumn

			( VTabCursor) EOF() bool
				https://sqlite.org/vtab.html#xeof

			( VTabCursor) Filter(idxNum int, idxStr string, arg ...Value) error
				https://sqlite.org/vtab.html#xfilter

			( VTabCursor) Next() error
				https://sqlite.org/vtab.html#xnext

			( VTabCursor) RowID() (int64, error)
				https://sqlite.org/vtab.html#xrowid

		As Outputs Of (at least 9)
			func VTab.Open() (VTabCursor, error)
			func VTabChecker.Open() (VTabCursor, error)
			func VTabDestroyer.Open() (VTabCursor, error)
			func VTabOverloader.Open() (VTabCursor, error)
			func VTabRenamer.Open() (VTabCursor, error)
			func VTabSavepointer.Open() (VTabCursor, error)
			func VTabShadowTabler.Open() (VTabCursor, error)
			func VTabTxn.Open() (VTabCursor, error)
			func VTabUpdater.Open() (VTabCursor, error)

	 type VTabDestroyer (interface)
		A VTabDestroyer allows a virtual table to drop persistent state.

		Methods (total 3)
			( VTabDestroyer) BestIndex(*IndexInfo) error
				https://sqlite.org/vtab.html#xbestindex

			( VTabDestroyer) Destroy() error
				https://sqlite.org/vtab.html#sqlite3_module.xDestroy

			( VTabDestroyer) Open() (VTabCursor, error)
				https://sqlite.org/vtab.html#xopen

		Implements (at least one exported)
			 VTabDestroyer : VTab

	 type VTabOverloader (interface)
		A VTabOverloader allows a virtual table to overload SQL functions.

		Methods (total 3)
			( VTabOverloader) BestIndex(*IndexInfo) error
				https://sqlite.org/vtab.html#xbestindex

			( VTabOverloader) FindFunction(arg int, name string) (ScalarFunction, IndexConstraintOp)
				https://sqlite.org/vtab.html#xfindfunction

			( VTabOverloader) Open() (VTabCursor, error)
				https://sqlite.org/vtab.html#xopen

		Implements (at least one exported)
			 VTabOverloader : VTab

	 type VTabRenamer (interface)
		A VTabRenamer allows a virtual table to be renamed.

		Methods (total 3)
			( VTabRenamer) BestIndex(*IndexInfo) error
				https://sqlite.org/vtab.html#xbestindex

			( VTabRenamer) Open() (VTabCursor, error)
				https://sqlite.org/vtab.html#xopen

			( VTabRenamer) Rename(new string) error
				https://sqlite.org/vtab.html#xrename

		Implements (at least one exported)
			 VTabRenamer : VTab

	 type VTabSavepointer (interface)
		A VTabSavepointer allows a virtual table to implement
		nested transactions.
		
		https://sqlite.org/vtab.html#xsavepoint

		Methods (total 9)
			( VTabSavepointer) Begin() error
				https://sqlite.org/vtab.html#xBegin

			( VTabSavepointer) BestIndex(*IndexInfo) error
				https://sqlite.org/vtab.html#xbestindex

			( VTabSavepointer) Commit() error
				https://sqlite.org/vtab.html#xcommit

			( VTabSavepointer) Open() (VTabCursor, error)
				https://sqlite.org/vtab.html#xopen

			( VTabSavepointer) Release(id int) error
			( VTabSavepointer) Rollback() error
				https://sqlite.org/vtab.html#xrollback

			( VTabSavepointer) RollbackTo(id int) error
			( VTabSavepointer) Savepoint(id int) error
			( VTabSavepointer) Sync() error
				https://sqlite.org/vtab.html#xsync

		Implements (at least 5)
			 VTabSavepointer : VTab
			 VTabSavepointer : VTabTxn
			 VTabSavepointer : github.com/polarsignals/frostdb.Sync
			 VTabSavepointer : database/sql/driver.Tx
			 VTabSavepointer : gorm.io/gorm.TxCommitter

	 type VTabShadowTabler (interface)
		A VTabShadowTabler allows a virtual table to protect the content
		of shadow tables from being corrupted by hostile SQL.
		
		Implementing this interface signals that a virtual table named
		"mumble" reserves all table names starting with "mumble_".

		Methods (total 3)
			( VTabShadowTabler) BestIndex(*IndexInfo) error
				https://sqlite.org/vtab.html#xbestindex

			( VTabShadowTabler) Open() (VTabCursor, error)
				https://sqlite.org/vtab.html#xopen

			( VTabShadowTabler) ShadowTables()
				https://sqlite.org/vtab.html#the_xshadowname_method

		Implements (at least one exported)
			 VTabShadowTabler : VTab

	 type VTabTxn (interface)
		A VTabTxn allows a virtual table to implement
		transactions with two-phase commit.
		
		Anything that is required as part of a commit that may fail
		should be performed in the Sync() callback.
		Current versions of SQLite ignore any errors
		returned by Commit() and Rollback().

		Methods (total 6)
			( VTabTxn) Begin() error
				https://sqlite.org/vtab.html#xBegin

			( VTabTxn) BestIndex(*IndexInfo) error
				https://sqlite.org/vtab.html#xbestindex

			( VTabTxn) Commit() error
				https://sqlite.org/vtab.html#xcommit

			( VTabTxn) Open() (VTabCursor, error)
				https://sqlite.org/vtab.html#xopen

			( VTabTxn) Rollback() error
				https://sqlite.org/vtab.html#xrollback

			( VTabTxn) Sync() error
				https://sqlite.org/vtab.html#xsync

		Implemented By (at least one exported)
			 VTabSavepointer (interface)
		Implements (at least 4)
			 VTabTxn : VTab
			 VTabTxn : github.com/polarsignals/frostdb.Sync
			 VTabTxn : database/sql/driver.Tx
			 VTabTxn : gorm.io/gorm.TxCommitter

	 type VTabUpdater (interface)
		A VTabUpdater allows a virtual table to be updated.
		Implementations must not retain arg.

		Methods (total 3)
			( VTabUpdater) BestIndex(*IndexInfo) error
				https://sqlite.org/vtab.html#xbestindex

			( VTabUpdater) Open() (VTabCursor, error)
				https://sqlite.org/vtab.html#xopen

			( VTabUpdater) Update(arg ...Value) (rowid int64, err error)
				https://sqlite.org/vtab.html#xupdate

		Implements (at least one exported)
			 VTabUpdater : VTab

	 type WindowFunction (interface)
		WindowFunction is the interface an aggregate window function should implement.
		
		https://sqlite.org/windowfunctions.html

		Methods (total 3)
			( WindowFunction) Inverse(ctx Context, arg ...Value)
				Inverse is invoked to remove the oldest presently aggregated result of Step from the current window.
				The function arguments, if any, are those passed to Step for the row being removed.
				Implementations must not retain arg.

			( WindowFunction) Step(ctx Context, arg ...Value)
				Step is invoked to add a row to the current window.
				The function arguments, if any, corresponding to the row being added, are passed to Step.
				Implementations must not retain arg.

			( WindowFunction) Value(ctx Context)
				Value is invoked to return the current (or final) value of the aggregate.

		Implements (at least one exported)
			 WindowFunction : AggregateFunction

	 type ZeroBlob int64 (basic type)
		ZeroBlob represents a zero-filled, length n BLOB
		that can be used as an argument to
		[database/sql.DB.Exec] and similar methods.


Package-Level Functions (total 11)

	 func AutoExtension(entryPoint func(*Conn) error)
		AutoExtension causes the entryPoint function to be invoked
		for each new database connection that is created.
		
		https://sqlite.org/c3ref/auto_extension.html

	 func ConfigLog(cb func(code ExtendedErrorCode, msg string))
		ConfigLog sets up the default error logging callback for new connections.
		
		https://sqlite.org/errlog.html

	 func CreateModule[T](db *Conn, name string, create, connect VTabConstructor[T]) error

		Type Parameters:
			T: VTab

		CreateModule registers a new virtual table module name.
		If create is nil, the virtual table is eponymous.
		
		https://sqlite.org/c3ref/create_module.html

	 func Initialize() error
		Initialize decodes and compiles the SQLite Wasm binary.
		This is called implicitly when the first connection is openned,
		but is potentially slow, so you may want to call it at a more convenient time.

	 func JSON(value any) any
		JSON returns a value that can be used as an argument to
		[database/sql.DB.Exec], [database/sql.Row.Scan] and similar methods to
		store value as JSON, or decode JSON into value.
		JSON should NOT be used with [Stmt.BindJSON], [Stmt.ColumnJSON],
		[Value.JSON], or [Context.ResultJSON].

	 func Open(filename string) (*Conn, error)
		Open calls [OpenFlags] with [OPEN_READWRITE], [OPEN_CREATE] and [OPEN_URI].

	 func OpenContext(ctx context.Context, filename string) (*Conn, error)
		OpenContext is like [Open] but includes a context,
		which is used to interrupt the process of opening the connection.

	 func OpenFlags(filename string, flags OpenFlag) (*Conn, error)
		OpenFlags opens an SQLite database file as specified by the filename argument.
		
		If none of the required flags are used, a combination of [OPEN_READWRITE] and [OPEN_CREATE] is used.
		If a URI filename is used, PRAGMA statements to execute can be specified using "_pragma":
		
			sqlite3.Open("file:demo.db?_pragma=busy_timeout(10000)")
		
		https://sqlite.org/c3ref/open.html

	 func Pointer(value any) any
		Pointer returns a pointer to a value that can be used as an argument to
		[database/sql.DB.Exec] and similar methods.
		Pointer should NOT be used with [Stmt.BindPointer],
		[Value.Pointer], or [Context.ResultPointer].
		
		https://sqlite.org/bindptr.html

	 func Quote(value any) string
		Quote escapes and quotes a value
		making it safe to embed in SQL text.
		Strings with embedded NUL characters are truncated.
		
		https://sqlite.org/lang_corefunc.html#quote

	 func QuoteIdentifier(id string) string
		QuoteIdentifier escapes and quotes an identifier
		making it safe to embed in SQL text.
		Strings with embedded NUL characters panic.


Package-Level Variables (total 3)

	  var Binary []byte // Wasm binary to load.
		Configure SQLite Wasm.
		
		Importing package embed initializes [Binary]
		with an appropriate build of SQLite:
		
			import _ "github.com/ncruces/go-sqlite3/embed"

	  var Path string // Path to load the binary from.
		Configure SQLite Wasm.
		
		Importing package embed initializes [Binary]
		with an appropriate build of SQLite:
		
			import _ "github.com/ncruces/go-sqlite3/embed"

	  var RuntimeConfig wazero.RuntimeConfig
		Configure SQLite Wasm.
		
		Importing package embed initializes [Binary]
		with an appropriate build of SQLite:
		
			import _ "github.com/ncruces/go-sqlite3/embed"


Package-Level Constants (total 295)

	const ABORT ErrorCode = 4 // Callback routine requested an abort
	const ABORT_ROLLBACK ExtendedErrorCode = 516
	const AUTH ErrorCode = 23 // Authorization denied
	const AUTH_ALTER_TABLE AuthorizerActionCode = 26 // Database Name   Table Name
	const AUTH_ANALYZE AuthorizerActionCode = 28 // Table Name      NULL
	const AUTH_ATTACH AuthorizerActionCode = 24 // Filename        NULL
	const AUTH_CREATE_INDEX AuthorizerActionCode = 1 // Index Name      Table Name
		**************************************************** 3rd ************ 4th **********

	const AUTH_CREATE_TABLE AuthorizerActionCode = 2 // Table Name      NULL
	const AUTH_CREATE_TEMP_INDEX AuthorizerActionCode = 3 // Index Name      Table Name
	const AUTH_CREATE_TEMP_TABLE AuthorizerActionCode = 4 // Table Name      NULL
	const AUTH_CREATE_TEMP_TRIGGER AuthorizerActionCode = 5 // Trigger Name    Table Name
	const AUTH_CREATE_TEMP_VIEW AuthorizerActionCode = 6 // View Name       NULL
	const AUTH_CREATE_TRIGGER AuthorizerActionCode = 7 // Trigger Name    Table Name
	const AUTH_CREATE_VIEW AuthorizerActionCode = 8 // View Name       NULL
	const AUTH_CREATE_VTABLE AuthorizerActionCode = 29 // Table Name      Module Name
	const AUTH_DELETE AuthorizerActionCode = 9 // Table Name      NULL
	const AUTH_DENY AuthorizerReturnCode = 1 // Abort the SQL statement with an error
	const AUTH_DETACH AuthorizerActionCode = 25 // Database Name   NULL
	const AUTH_DROP_INDEX AuthorizerActionCode = 10 // Index Name      Table Name
	const AUTH_DROP_TABLE AuthorizerActionCode = 11 // Table Name      NULL
	const AUTH_DROP_TEMP_INDEX AuthorizerActionCode = 12 // Index Name      Table Name
	const AUTH_DROP_TEMP_TABLE AuthorizerActionCode = 13 // Table Name      NULL
	const AUTH_DROP_TEMP_TRIGGER AuthorizerActionCode = 14 // Trigger Name    Table Name
	const AUTH_DROP_TEMP_VIEW AuthorizerActionCode = 15 // View Name       NULL
	const AUTH_DROP_TRIGGER AuthorizerActionCode = 16 // Trigger Name    Table Name
	const AUTH_DROP_VIEW AuthorizerActionCode = 17 // View Name       NULL
	const AUTH_DROP_VTABLE AuthorizerActionCode = 30 // Table Name      Module Name
	const AUTH_FUNCTION AuthorizerActionCode = 31 // NULL            Function Name
	const AUTH_IGNORE AuthorizerReturnCode = 2 // Don't allow access, but don't generate an error
	const AUTH_INSERT AuthorizerActionCode = 18 // Table Name      NULL
	const AUTH_OK AuthorizerReturnCode = 0
	const AUTH_PRAGMA AuthorizerActionCode = 19 // Pragma Name     1st arg or NULL
	const AUTH_READ AuthorizerActionCode = 20 // Table Name      Column Name
	const AUTH_RECURSIVE AuthorizerActionCode = 33 // NULL            NULL
	const AUTH_REINDEX AuthorizerActionCode = 27 // Index Name      NULL
	const AUTH_SAVEPOINT AuthorizerActionCode = 32 // Operation       Savepoint Name
	const AUTH_SELECT AuthorizerActionCode = 21 // NULL            NULL
	const AUTH_TRANSACTION AuthorizerActionCode = 22 // Operation       NULL
	const AUTH_UPDATE AuthorizerActionCode = 23 // Table Name      Column Name
	const AUTH_USER ExtendedErrorCode = 279
	const BLOB Datatype = 4
	const BUSY ErrorCode = 5 // The database file is locked
	const BUSY_RECOVERY ExtendedErrorCode = 261
	const BUSY_SNAPSHOT ExtendedErrorCode = 517
	const BUSY_TIMEOUT ExtendedErrorCode = 773
	const CANTOPEN ErrorCode = 14 // Unable to open the database file
	const CANTOPEN_CONVPATH ExtendedErrorCode = 1038
	const CANTOPEN_FULLPATH ExtendedErrorCode = 782
	const CANTOPEN_ISDIR ExtendedErrorCode = 526
	const CANTOPEN_NOTEMPDIR ExtendedErrorCode = 270
	const CANTOPEN_SYMLINK ExtendedErrorCode = 1550
		CANTOPEN_DIRTYWAL    ExtendedErrorCode = xErrorCode(CANTOPEN) | (5 << 8) /* Not Used */

	const CHECKPOINT_FULL CheckpointMode = 1 // Wait for writers, then checkpoint
	const CHECKPOINT_PASSIVE CheckpointMode = 0 // Do as much as possible w/o blocking
	const CHECKPOINT_RESTART CheckpointMode = 2 // Like FULL but wait for readers
	const CHECKPOINT_TRUNCATE CheckpointMode = 3 // Like RESTART but also truncate WAL
	const CONSTRAINT ErrorCode = 19 // Abort due to constraint violation
	const CONSTRAINT_CHECK ExtendedErrorCode = 275
	const CONSTRAINT_COMMITHOOK ExtendedErrorCode = 531
	const CONSTRAINT_DATATYPE ExtendedErrorCode = 3091
	const CONSTRAINT_FOREIGNKEY ExtendedErrorCode = 787
	const CONSTRAINT_FUNCTION ExtendedErrorCode = 1043
	const CONSTRAINT_NOTNULL ExtendedErrorCode = 1299
	const CONSTRAINT_PINNED ExtendedErrorCode = 2835
	const CONSTRAINT_PRIMARYKEY ExtendedErrorCode = 1555
	const CONSTRAINT_ROWID ExtendedErrorCode = 2579
	const CONSTRAINT_TRIGGER ExtendedErrorCode = 1811
	const CONSTRAINT_UNIQUE ExtendedErrorCode = 2067
	const CONSTRAINT_VTAB ExtendedErrorCode = 2323
	const CORRUPT ErrorCode = 11 // The database disk image is malformed
	const CORRUPT_INDEX ExtendedErrorCode = 779
	const CORRUPT_SEQUENCE ExtendedErrorCode = 523
	const CORRUPT_VTAB ExtendedErrorCode = 267
	const DBCONFIG_DEFENSIVE DBConfig = 1010
	const DBCONFIG_DQS_DDL DBConfig = 1014
	const DBCONFIG_DQS_DML DBConfig = 1013
	const DBCONFIG_ENABLE_ATTACH_CREATE DBConfig = 1020
	const DBCONFIG_ENABLE_ATTACH_WRITE DBConfig = 1021
	const DBCONFIG_ENABLE_COMMENTS DBConfig = 1022
	const DBCONFIG_ENABLE_FKEY DBConfig = 1002
		DBCONFIG_MAINDBNAME         DBConfig = 1000
		DBCONFIG_LOOKASIDE          DBConfig = 1001

	const DBCONFIG_ENABLE_FTS3_TOKENIZER DBConfig = 1004
	const DBCONFIG_ENABLE_LOAD_EXTENSION DBConfig = 1005
	const DBCONFIG_ENABLE_QPSG DBConfig = 1007
	const DBCONFIG_ENABLE_TRIGGER DBConfig = 1003
	const DBCONFIG_ENABLE_VIEW DBConfig = 1015
	const DBCONFIG_LEGACY_ALTER_TABLE DBConfig = 1012
	const DBCONFIG_LEGACY_FILE_FORMAT DBConfig = 1016
	const DBCONFIG_NO_CKPT_ON_CLOSE DBConfig = 1006
	const DBCONFIG_RESET_DATABASE DBConfig = 1009
	const DBCONFIG_REVERSE_SCANORDER DBConfig = 1019
	const DBCONFIG_STMT_SCANSTATUS DBConfig = 1018
	const DBCONFIG_TRIGGER_EQP DBConfig = 1008
	const DBCONFIG_TRUSTED_SCHEMA DBConfig = 1017
	const DBCONFIG_WRITABLE_SCHEMA DBConfig = 1011
	const DBSTATUS_CACHE_HIT DBStatus = 7
	const DBSTATUS_CACHE_MISS DBStatus = 8
	const DBSTATUS_CACHE_SPILL DBStatus = 12
	const DBSTATUS_CACHE_USED DBStatus = 1
	const DBSTATUS_CACHE_USED_SHARED DBStatus = 11
	const DBSTATUS_CACHE_WRITE DBStatus = 9
	const DBSTATUS_DEFERRED_FKS DBStatus = 10
	const DBSTATUS_LOOKASIDE_HIT DBStatus = 4
	const DBSTATUS_LOOKASIDE_MISS_FULL DBStatus = 6
	const DBSTATUS_LOOKASIDE_MISS_SIZE DBStatus = 5
	const DBSTATUS_LOOKASIDE_USED DBStatus = 0
	const DBSTATUS_SCHEMA_USED DBStatus = 2
	const DBSTATUS_STMT_USED DBStatus = 3
	const DETERMINISTIC FunctionFlag = 2048
	const DIRECTONLY FunctionFlag = 524288
	const EMPTY ErrorCode = 16 // Internal use only
	const ERROR ErrorCode = 1 // Generic error
	const ERROR_MISSING_COLLSEQ ExtendedErrorCode = 257
	const ERROR_RETRY ExtendedErrorCode = 513
	const ERROR_SNAPSHOT ExtendedErrorCode = 769
	const FCNTL_CHUNK_SIZE FcntlOpcode = 6
	const FCNTL_DATA_VERSION FcntlOpcode = 35
	const FCNTL_FILE_POINTER FcntlOpcode = 7
	const FCNTL_JOURNAL_POINTER FcntlOpcode = 28
	const FCNTL_LOCKSTATE FcntlOpcode = 1
	const FCNTL_NULL_IO FcntlOpcode = 43
	const FCNTL_PERSIST_WAL FcntlOpcode = 10
	const FCNTL_POWERSAFE_OVERWRITE FcntlOpcode = 13
	const FCNTL_RESERVE_BYTES FcntlOpcode = 38
	const FCNTL_RESET_CACHE FcntlOpcode = 42
	const FCNTL_VFS_POINTER FcntlOpcode = 27
	const FLOAT Datatype = 2
	const FORMAT ErrorCode = 24 // Not used
	const FULL ErrorCode = 13 // Insertion failed because database is full
	const INDEX_CONSTRAINT_EQ IndexConstraintOp = 2
	const INDEX_CONSTRAINT_FUNCTION IndexConstraintOp = 150
	const INDEX_CONSTRAINT_GE IndexConstraintOp = 32
	const INDEX_CONSTRAINT_GLOB IndexConstraintOp = 66
	const INDEX_CONSTRAINT_GT IndexConstraintOp = 4
	const INDEX_CONSTRAINT_IS IndexConstraintOp = 72
	const INDEX_CONSTRAINT_ISNOT IndexConstraintOp = 69
	const INDEX_CONSTRAINT_ISNOTNULL IndexConstraintOp = 70
	const INDEX_CONSTRAINT_ISNULL IndexConstraintOp = 71
	const INDEX_CONSTRAINT_LE IndexConstraintOp = 8
	const INDEX_CONSTRAINT_LIKE IndexConstraintOp = 65
	const INDEX_CONSTRAINT_LIMIT IndexConstraintOp = 73
	const INDEX_CONSTRAINT_LT IndexConstraintOp = 16
	const INDEX_CONSTRAINT_MATCH IndexConstraintOp = 64
	const INDEX_CONSTRAINT_NE IndexConstraintOp = 68
	const INDEX_CONSTRAINT_OFFSET IndexConstraintOp = 74
	const INDEX_CONSTRAINT_REGEXP IndexConstraintOp = 67
	const INDEX_SCAN_UNIQUE IndexScanFlag = 1
	const INNOCUOUS FunctionFlag = 2097152
	const INTEGER Datatype = 1
	const INTERNAL ErrorCode = 2 // Internal logic error in SQLite
	const INTERRUPT ErrorCode = 9 // Operation terminated by sqlite3_interrupt()
	const IOERR ErrorCode = 10 // Some kind of disk I/O error occurred
	const IOERR_ACCESS ExtendedErrorCode = 3338
	const IOERR_AUTH ExtendedErrorCode = 7178
	const IOERR_BEGIN_ATOMIC ExtendedErrorCode = 7434
	const IOERR_BLOCKED ExtendedErrorCode = 2826
	const IOERR_CHECKRESERVEDLOCK ExtendedErrorCode = 3594
	const IOERR_CLOSE ExtendedErrorCode = 4106
	const IOERR_COMMIT_ATOMIC ExtendedErrorCode = 7690
	const IOERR_CONVPATH ExtendedErrorCode = 6666
	const IOERR_CORRUPTFS ExtendedErrorCode = 8458
	const IOERR_DATA ExtendedErrorCode = 8202
	const IOERR_DELETE ExtendedErrorCode = 2570
	const IOERR_DELETE_NOENT ExtendedErrorCode = 5898
	const IOERR_DIR_CLOSE ExtendedErrorCode = 4362
	const IOERR_DIR_FSYNC ExtendedErrorCode = 1290
	const IOERR_FSTAT ExtendedErrorCode = 1802
	const IOERR_FSYNC ExtendedErrorCode = 1034
	const IOERR_GETTEMPPATH ExtendedErrorCode = 6410
	const IOERR_IN_PAGE ExtendedErrorCode = 8714
	const IOERR_LOCK ExtendedErrorCode = 3850
	const IOERR_MMAP ExtendedErrorCode = 6154
	const IOERR_NOMEM ExtendedErrorCode = 3082
	const IOERR_RDLOCK ExtendedErrorCode = 2314
	const IOERR_READ ExtendedErrorCode = 266
	const IOERR_ROLLBACK_ATOMIC ExtendedErrorCode = 7946
	const IOERR_SEEK ExtendedErrorCode = 5642
	const IOERR_SHMLOCK ExtendedErrorCode = 5130
	const IOERR_SHMMAP ExtendedErrorCode = 5386
	const IOERR_SHMOPEN ExtendedErrorCode = 4618
	const IOERR_SHMSIZE ExtendedErrorCode = 4874
	const IOERR_SHORT_READ ExtendedErrorCode = 522
	const IOERR_TRUNCATE ExtendedErrorCode = 1546
	const IOERR_UNLOCK ExtendedErrorCode = 2058
	const IOERR_VNODE ExtendedErrorCode = 6922
	const IOERR_WRITE ExtendedErrorCode = 778
	const LIMIT_ATTACHED LimitCategory = 7
	const LIMIT_COLUMN LimitCategory = 2
	const LIMIT_COMPOUND_SELECT LimitCategory = 4
	const LIMIT_EXPR_DEPTH LimitCategory = 3
	const LIMIT_FUNCTION_ARG LimitCategory = 6
	const LIMIT_LENGTH LimitCategory = 0
	const LIMIT_LIKE_PATTERN_LENGTH LimitCategory = 8
	const LIMIT_SQL_LENGTH LimitCategory = 1
	const LIMIT_TRIGGER_DEPTH LimitCategory = 10
	const LIMIT_VARIABLE_NUMBER LimitCategory = 9
	const LIMIT_VDBE_OP LimitCategory = 5
	const LIMIT_WORKER_THREADS LimitCategory = 11
	const LOCKED ErrorCode = 6 // A table in the database is locked
	const LOCKED_SHAREDCACHE ExtendedErrorCode = 262
	const LOCKED_VTAB ExtendedErrorCode = 518
	const MISMATCH ErrorCode = 20 // Data type mismatch
	const MISUSE ErrorCode = 21 // Library used incorrectly
	const NOLFS ErrorCode = 22 // Uses OS features not supported on host
	const NOMEM ErrorCode = 7 // A malloc() failed
	const NOTADB ErrorCode = 26 // File opened that is not a database file
	const NOTFOUND ErrorCode = 12 // Unknown opcode in sqlite3_file_control()
	const NOTICE ErrorCode = 27 // Notifications from sqlite3_log()
	const NOTICE_RBU ExtendedErrorCode = 795
	const NOTICE_RECOVER_ROLLBACK ExtendedErrorCode = 539
	const NOTICE_RECOVER_WAL ExtendedErrorCode = 283
	const NULL Datatype = 5
	const OPEN_CREATE OpenFlag = 4 // Ok for sqlite3_open_v2()
	const OPEN_EXRESCODE OpenFlag = 33554432 // Extended result codes
	const OPEN_FULLMUTEX OpenFlag = 65536 // Ok for sqlite3_open_v2()
	const OPEN_MEMORY OpenFlag = 128 // Ok for sqlite3_open_v2()
	const OPEN_NOFOLLOW OpenFlag = 16777216 // Ok for sqlite3_open_v2()
	const OPEN_NOMUTEX OpenFlag = 32768 // Ok for sqlite3_open_v2()
	const OPEN_PRIVATECACHE OpenFlag = 262144 // Ok for sqlite3_open_v2()
	const OPEN_READONLY OpenFlag = 1 // Ok for sqlite3_open_v2()
	const OPEN_READWRITE OpenFlag = 2 // Ok for sqlite3_open_v2()
	const OPEN_SHAREDCACHE OpenFlag = 131072 // Ok for sqlite3_open_v2()
	const OPEN_URI OpenFlag = 64 // Ok for sqlite3_open_v2()
	const PERM ErrorCode = 3 // Access permission denied
	const PREPARE_DONT_LOG PrepareFlag = 16
	const PREPARE_NO_VTAB PrepareFlag = 4
	const PREPARE_NORMALIZE PrepareFlag = 2
	const PREPARE_PERSISTENT PrepareFlag = 1
	const PROTOCOL ErrorCode = 15 // Database lock protocol error
	const RANGE ErrorCode = 25 // 2nd parameter to sqlite3_bind out of range
	const READONLY ErrorCode = 8 // Attempt to write a readonly database
	const READONLY_CANTINIT ExtendedErrorCode = 1288
	const READONLY_CANTLOCK ExtendedErrorCode = 520
	const READONLY_DBMOVED ExtendedErrorCode = 1032
	const READONLY_DIRECTORY ExtendedErrorCode = 1544
	const READONLY_RECOVERY ExtendedErrorCode = 264
	const READONLY_ROLLBACK ExtendedErrorCode = 776
	const RESULT_SUBTYPE FunctionFlag = 16777216
	const SCHEMA ErrorCode = 17 // The database schema changed
	const SELFORDER1 FunctionFlag = 33554432
	const STMTSTATUS_AUTOINDEX StmtStatus = 3
	const STMTSTATUS_FILTER_HIT StmtStatus = 8
	const STMTSTATUS_FILTER_MISS StmtStatus = 7
	const STMTSTATUS_FULLSCAN_STEP StmtStatus = 1
	const STMTSTATUS_MEMUSED StmtStatus = 99
	const STMTSTATUS_REPREPARE StmtStatus = 5
	const STMTSTATUS_RUN StmtStatus = 6
	const STMTSTATUS_SORT StmtStatus = 2
	const STMTSTATUS_VM_STEP StmtStatus = 4
	const SUBTYPE FunctionFlag = 1048576
	const TEXT Datatype = 3
	const TimeFormat1 TimeFormat = "2006-01-02"
		Text formats

	const TimeFormat10 TimeFormat = "15:04:05.000"
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TimeFormat10TZ TimeFormat = "15:04:05.000Z07:00"
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TimeFormat2 TimeFormat = "2006-01-02 15:04"
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TimeFormat2TZ TimeFormat = "2006-01-02 15:04Z07:00"
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TimeFormat3 TimeFormat = "2006-01-02 15:04:05"
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TimeFormat3TZ TimeFormat = "2006-01-02 15:04:05Z07:00"
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TimeFormat4 TimeFormat = "2006-01-02 15:04:05.000"
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TimeFormat4TZ TimeFormat = "2006-01-02 15:04:05.000Z07:00"
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TimeFormat5 TimeFormat = "2006-01-02T15:04"
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TimeFormat5TZ TimeFormat = "2006-01-02T15:04Z07:00"
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TimeFormat6 TimeFormat = "2006-01-02T15:04:05"
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TimeFormat6TZ TimeFormat = "2006-01-02T15:04:05Z07:00"
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TimeFormat7 TimeFormat = "2006-01-02T15:04:05.000"
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TimeFormat7TZ TimeFormat = "2006-01-02T15:04:05.000Z07:00"
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TimeFormat8 TimeFormat = "15:04"
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TimeFormat8TZ TimeFormat = "15:04Z07:00"
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TimeFormat9 TimeFormat = "15:04:05"
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TimeFormat9TZ TimeFormat = "15:04:05Z07:00"
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TimeFormatAuto TimeFormat = "auto"
		Auto

	const TimeFormatDefault TimeFormat = "" // time.RFC3339Nano
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TimeFormatJulianDay TimeFormat = "julianday"
		Numeric formats

	const TimeFormatUnix TimeFormat = "unixepoch"
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TimeFormatUnixFrac TimeFormat = "unixepoch_frac"
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TimeFormatUnixMicro TimeFormat = "unixepoch_micro" // not an SQLite format
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TimeFormatUnixMilli TimeFormat = "unixepoch_milli" // not an SQLite format
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TimeFormatUnixNano TimeFormat = "unixepoch_nano" // not an SQLite format
		TimeFormats recognized by SQLite to encode/decode time values.
		
		https://sqlite.org/lang_datefunc.html#time_values

	const TOOBIG ErrorCode = 18 // String or BLOB exceeds size limit
	const TRACE_CLOSE TraceEvent = 8
	const TRACE_PROFILE TraceEvent = 2
	const TRACE_ROW TraceEvent = 4
	const TRACE_STMT TraceEvent = 1
	const TXN_NONE TxnState = 0
	const TXN_READ TxnState = 1
	const TXN_WRITE TxnState = 2
	const VTAB_ABORT VTabConflictMode = 4
	const VTAB_CONSTRAINT_SUPPORT VTabConfigOption = 1
	const VTAB_DIRECTONLY VTabConfigOption = 3
	const VTAB_FAIL VTabConflictMode = 3
	const VTAB_IGNORE VTabConflictMode = 2
	const VTAB_INNOCUOUS VTabConfigOption = 2
	const VTAB_REPLACE VTabConflictMode = 5
	const VTAB_ROLLBACK VTabConflictMode = 1
	const VTAB_USES_ALL_SCHEMAS VTabConfigOption = 4
	const WARNING ErrorCode = 28 // Warnings from sqlite3_log()
	const WARNING_AUTOINDEX ExtendedErrorCode = 284

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.