Documentation

Overview

Package sqlite3 provides an interface to SQLite version 3 databases.

Database connections are created either by using this package directly or with the "sqlite3" database/sql driver. The direct interface, which is described below, exposes SQLite-specific features, such as incremental I/O and online backups. The driver is recommended when your application has to support multiple database engines.

Installation

Minimum requirements are Go 1.1+ with CGO enabled and GCC/MinGW C compiler. The SQLite amalgamation version 3.8.5 (2014-06-04) is compiled as part of the package (see http://www.sqlite.org/amalgamation.html). Compilation options are defined at the top of sqlite3.go (#cgo CFLAGS). Dynamic linking with a shared SQLite library is not supported.

Windows users should install mingw-w64 (http://mingw-w64.sourceforge.net/), TDM64-GCC (http://tdm-gcc.tdragon.net/), or another MinGW distribution, and make sure that gcc.exe is available from the %PATH%. MSYS is not required.

Run 'go get github.com/mxk/go-sqlite/sqlite3' to download, build, and install the package.

Concurrency

A single connection instance and all of its derived objects (prepared statements, backup operations, etc.) may NOT be used concurrently from multiple goroutines without external synchronization. The only exception is Conn.Interrupt(), which may be called from another goroutine to abort a long-running operation. It is safe to use separate connection instances concurrently, even if they are accessing the same database file. For example:

// ERROR (without any extra synchronization)
c, _ := sqlite3.Open("sqlite.db")
go use(c)
go use(c)

// OK
c1, _ := sqlite3.Open("sqlite.db")
c2, _ := sqlite3.Open("sqlite.db")
go use(c1)
go use(c2)

Maps

Use NamedArgs map to bind values to named statement parameters (see http://www.sqlite.org/lang_expr.html#varparam). Use RowMap to retrieve the current row as a map of column/value pairs. Here is a short example with the error-handling code omitted for brevity:

c, _ := sqlite3.Open(":memory:")
c.Exec("CREATE TABLE x(a, b, c)")

args := sqlite3.NamedArgs{"$a": 1, "$b": "demo"}
c.Exec("INSERT INTO x VALUES($a, $b, $c)", args) // $c will be NULL

sql := "SELECT rowid, * FROM x"
row := make(sqlite3.RowMap)
for s, err := c.Query(sql); err == nil; err = s.Next() {
	var rowid int64
	s.Scan(&rowid, row)     // Assigns 1st column to rowid, the rest to row
	fmt.Println(rowid, row) // Prints "1 map[a:1 b:demo c:<nil>]"
}

Data Types

See http://www.sqlite.org/datatype3.html for a description of the SQLite data type system. The following Go data types are supported as arguments to prepared statements and may be used in NamedArgs:

Go Type    SQLite Type  Notes
---------  -----------  ----------------------------------------------------
<nil>      NULL         Unbound parameters are NULL by default.
int        INTEGER
int64      INTEGER
float64    FLOAT
bool       INTEGER      Converted as false = 0, true = 1.
string     TEXT         SQLite makes a private copy when the value is bound.
[]byte     BLOB         SQLite makes a private copy when the value is bound.
time.Time  INTEGER      Converted by calling Unix().
RawString  TEXT         SQLite uses the value directly without copying. The
                        caller must keep a reference to the value for the
                        duration of the query to prevent garbage collection.
RawBytes   BLOB         Same as RawString. The value must not be modified
                        for the duration of the query.
ZeroBlob   BLOB         Allocates a zero-filled BLOB of the specified length
                        (e.g. ZeroBlob(4096) allocates 4KB).

Note that the table above describes how the value is bound to the statement. The final storage class is determined according to the column affinity rules.

See http://www.sqlite.org/c3ref/column_blob.html for a description of how column values are retrieved from the results of a query. The following static Go data types are supported for retrieving column values:

Go Type     Req. Type  Notes
----------  ---------  ---------------------------------------------------
*int        INTEGER
*int64      INTEGER
*float64    FLOAT
*bool       INTEGER    Converted as 0 = false, otherwise true.
*string     TEXT       The caller receives a copy of the value.
*[]byte     BLOB       The caller receives a copy of the value.
*time.Time  INTEGER    Converted by calling time.Unix(). Text values are not
                       supported, but the conversion can be performed with
                       the date and time SQL functions.
*RawString  TEXT       The value is used directly without copying and
                       remains valid until the next Stmt method call.
*RawBytes   BLOB       Same as *RawString. The value must not be modified.
                       Re-slicing is ok, but be careful with append().
io.Writer   BLOB       The value is written out directly into the writer.

For *interface{} and RowMap arguments, the Go data type is dynamically selected based on the SQLite storage class and column declaration prefix:

SQLite Type  Col. Decl.  Go Type    Notes
-----------  ----------  ---------  ----------------------------------------
NULL                     <nil>
INTEGER      "DATE..."   time.Time  Converted by calling time.Unix().
INTEGER      "TIME..."   time.Time  Converted by calling time.Unix().
INTEGER      "BOOL..."   bool       Converted as 0 = false, otherwise true.
INTEGER                  int64
FLOAT                    float64
TEXT                     string
BLOB                     []byte

Database Names

Methods that require a database name as one of the arguments (e.g. Conn.Path()) expect the symbolic name by which the database is known to the connection, not a path to a file. Valid database names are "main", "temp", or a name specified after the AS clause in an ATTACH statement.

Callbacks

SQLite can execute callbacks for various internal events. The package provides types and methods for registering callback handlers. Unless stated otherwise in SQLite documentation, callback handlers are not reentrant and must not do anything to modify the associated database connection. This includes preparing/running any other SQL statements. The safest bet is to avoid all interactions with Conn, Stmt, and other related objects within the handler.

Codecs and Encryption

SQLite has an undocumented codec API, which operates between the pager and VFS layers, and is used by the SQLite Encryption Extension (SEE) to encrypt database and journal contents. Consider purchasing a SEE license if you require production-quality encryption support (http://www.hwaci.com/sw/sqlite/see.html).

This package has an experimental API (read: unstable, may eat your data) for writing codecs in Go. The "codec" subpackage provides additional documentation and several existing codec implementations.

Codecs are registered via the RegisterCodec function for a specific key prefix. For example, the "aes-hmac" codec is initialized when a key in the format "aes-hmac:<...>" is provided to an attached database. The key format after the first colon is codec-specific. See CodecFunc for more information.

The codec API has several limitations. Codecs cannot be used for in-memory or temporary databases. Once a database is created, the page size and the amount of reserved space at the end of each page cannot be changed (i.e. "PRAGMA page_size=N; VACUUM;" will not work). Online backups will fail unless the destination database has the same page size and reserve values. Bytes 16 through 23 of page 1 (the database header, see http://www.sqlite.org/fileformat2.html) cannot be altered, so it is always possible to identify encrypted SQLite databases.

The rekey function is currently not implemented. The key can only be changed via the backup API or by dumping and restoring the database contents.

Index

Constants

View Source
const (
	INTEGER = C.SQLITE_INTEGER // 1
	FLOAT   = C.SQLITE_FLOAT   // 2
	TEXT    = C.SQLITE_TEXT    // 3
	BLOB    = C.SQLITE_BLOB    // 4
	NULL    = C.SQLITE_NULL    // 5
)

    Fundamental SQLite data types. These are returned by Stmt.DataTypes method. [http://www.sqlite.org/c3ref/c_blob.html]

    View Source
    const (
    	OK         = C.SQLITE_OK         // 0   = Successful result
    	ERROR      = C.SQLITE_ERROR      // 1   = SQL error or missing database
    	INTERNAL   = C.SQLITE_INTERNAL   // 2   = Internal logic error in SQLite
    	PERM       = C.SQLITE_PERM       // 3   = Access permission denied
    	ABORT      = C.SQLITE_ABORT      // 4   = Callback routine requested an abort
    	BUSY       = C.SQLITE_BUSY       // 5   = The database file is locked
    	LOCKED     = C.SQLITE_LOCKED     // 6   = A table in the database is locked
    	NOMEM      = C.SQLITE_NOMEM      // 7   = A malloc() failed
    	READONLY   = C.SQLITE_READONLY   // 8   = Attempt to write a readonly database
    	INTERRUPT  = C.SQLITE_INTERRUPT  // 9   = Operation terminated by sqlite3_interrupt()
    	IOERR      = C.SQLITE_IOERR      // 10  = Some kind of disk I/O error occurred
    	CORRUPT    = C.SQLITE_CORRUPT    // 11  = The database disk image is malformed
    	NOTFOUND   = C.SQLITE_NOTFOUND   // 12  = Unknown opcode in sqlite3_file_control()
    	FULL       = C.SQLITE_FULL       // 13  = Insertion failed because database is full
    	CANTOPEN   = C.SQLITE_CANTOPEN   // 14  = Unable to open the database file
    	PROTOCOL   = C.SQLITE_PROTOCOL   // 15  = Database lock protocol error
    	EMPTY      = C.SQLITE_EMPTY      // 16  = Database is empty
    	SCHEMA     = C.SQLITE_SCHEMA     // 17  = The database schema changed
    	TOOBIG     = C.SQLITE_TOOBIG     // 18  = String or BLOB exceeds size limit
    	CONSTRAINT = C.SQLITE_CONSTRAINT // 19  = Abort due to constraint violation
    	MISMATCH   = C.SQLITE_MISMATCH   // 20  = Data type mismatch
    	MISUSE     = C.SQLITE_MISUSE     // 21  = Library used incorrectly
    	NOLFS      = C.SQLITE_NOLFS      // 22  = Uses OS features not supported on host
    	AUTH       = C.SQLITE_AUTH       // 23  = Authorization denied
    	FORMAT     = C.SQLITE_FORMAT     // 24  = Auxiliary database format error
    	RANGE      = C.SQLITE_RANGE      // 25  = 2nd parameter to sqlite3_bind out of range
    	NOTADB     = C.SQLITE_NOTADB     // 26  = File opened that is not a database file
    	NOTICE     = C.SQLITE_NOTICE     // 27  = Notifications from sqlite3_log()
    	WARNING    = C.SQLITE_WARNING    // 28  = Warnings from sqlite3_log()
    	ROW        = C.SQLITE_ROW        // 100 = sqlite3_step() has another row ready
    	DONE       = C.SQLITE_DONE       // 101 = sqlite3_step() has finished executing
    )

      General result codes returned by the SQLite API. When converted to an error, OK and ROW become nil, and DONE becomes either nil or io.EOF, depending on the context in which the statement is executed. All other codes are returned via the Error struct. [http://www.sqlite.org/c3ref/c_abort.html]

      View Source
      const (
      	IOERR_READ              = C.SQLITE_IOERR_READ              // (SQLITE_IOERR | (1<<8))
      	IOERR_SHORT_READ        = C.SQLITE_IOERR_SHORT_READ        // (SQLITE_IOERR | (2<<8))
      	IOERR_WRITE             = C.SQLITE_IOERR_WRITE             // (SQLITE_IOERR | (3<<8))
      	IOERR_FSYNC             = C.SQLITE_IOERR_FSYNC             // (SQLITE_IOERR | (4<<8))
      	IOERR_DIR_FSYNC         = C.SQLITE_IOERR_DIR_FSYNC         // (SQLITE_IOERR | (5<<8))
      	IOERR_TRUNCATE          = C.SQLITE_IOERR_TRUNCATE          // (SQLITE_IOERR | (6<<8))
      	IOERR_FSTAT             = C.SQLITE_IOERR_FSTAT             // (SQLITE_IOERR | (7<<8))
      	IOERR_UNLOCK            = C.SQLITE_IOERR_UNLOCK            // (SQLITE_IOERR | (8<<8))
      	IOERR_RDLOCK            = C.SQLITE_IOERR_RDLOCK            // (SQLITE_IOERR | (9<<8))
      	IOERR_DELETE            = C.SQLITE_IOERR_DELETE            // (SQLITE_IOERR | (10<<8))
      	IOERR_BLOCKED           = C.SQLITE_IOERR_BLOCKED           // (SQLITE_IOERR | (11<<8))
      	IOERR_NOMEM             = C.SQLITE_IOERR_NOMEM             // (SQLITE_IOERR | (12<<8))
      	IOERR_ACCESS            = C.SQLITE_IOERR_ACCESS            // (SQLITE_IOERR | (13<<8))
      	IOERR_CHECKRESERVEDLOCK = C.SQLITE_IOERR_CHECKRESERVEDLOCK // (SQLITE_IOERR | (14<<8))
      	IOERR_LOCK              = C.SQLITE_IOERR_LOCK              // (SQLITE_IOERR | (15<<8))
      	IOERR_CLOSE             = C.SQLITE_IOERR_CLOSE             // (SQLITE_IOERR | (16<<8))
      	IOERR_DIR_CLOSE         = C.SQLITE_IOERR_DIR_CLOSE         // (SQLITE_IOERR | (17<<8))
      	IOERR_SHMOPEN           = C.SQLITE_IOERR_SHMOPEN           // (SQLITE_IOERR | (18<<8))
      	IOERR_SHMSIZE           = C.SQLITE_IOERR_SHMSIZE           // (SQLITE_IOERR | (19<<8))
      	IOERR_SHMLOCK           = C.SQLITE_IOERR_SHMLOCK           // (SQLITE_IOERR | (20<<8))
      	IOERR_SHMMAP            = C.SQLITE_IOERR_SHMMAP            // (SQLITE_IOERR | (21<<8))
      	IOERR_SEEK              = C.SQLITE_IOERR_SEEK              // (SQLITE_IOERR | (22<<8))
      	IOERR_DELETE_NOENT      = C.SQLITE_IOERR_DELETE_NOENT      // (SQLITE_IOERR | (23<<8))
      	IOERR_MMAP              = C.SQLITE_IOERR_MMAP              // (SQLITE_IOERR | (24<<8))
      	IOERR_GETTEMPPATH       = C.SQLITE_IOERR_GETTEMPPATH       // (SQLITE_IOERR | (25<<8))
      	IOERR_CONVPATH          = C.SQLITE_IOERR_CONVPATH          // (SQLITE_IOERR | (26<<8))
      	LOCKED_SHAREDCACHE      = C.SQLITE_LOCKED_SHAREDCACHE      // (SQLITE_LOCKED |  (1<<8))
      	BUSY_RECOVERY           = C.SQLITE_BUSY_RECOVERY           // (SQLITE_BUSY   |  (1<<8))
      	BUSY_SNAPSHOT           = C.SQLITE_BUSY_SNAPSHOT           // (SQLITE_BUSY   |  (2<<8))
      	CANTOPEN_NOTEMPDIR      = C.SQLITE_CANTOPEN_NOTEMPDIR      // (SQLITE_CANTOPEN | (1<<8))
      	CANTOPEN_ISDIR          = C.SQLITE_CANTOPEN_ISDIR          // (SQLITE_CANTOPEN | (2<<8))
      	CANTOPEN_FULLPATH       = C.SQLITE_CANTOPEN_FULLPATH       // (SQLITE_CANTOPEN | (3<<8))
      	CANTOPEN_CONVPATH       = C.SQLITE_CANTOPEN_CONVPATH       // (SQLITE_CANTOPEN | (4<<8))
      	CORRUPT_VTAB            = C.SQLITE_CORRUPT_VTAB            // (SQLITE_CORRUPT | (1<<8))
      	READONLY_RECOVERY       = C.SQLITE_READONLY_RECOVERY       // (SQLITE_READONLY | (1<<8))
      	READONLY_CANTLOCK       = C.SQLITE_READONLY_CANTLOCK       // (SQLITE_READONLY | (2<<8))
      	READONLY_ROLLBACK       = C.SQLITE_READONLY_ROLLBACK       // (SQLITE_READONLY | (3<<8))
      	READONLY_DBMOVED        = C.SQLITE_READONLY_DBMOVED        // (SQLITE_READONLY | (4<<8))
      	ABORT_ROLLBACK          = C.SQLITE_ABORT_ROLLBACK          // (SQLITE_ABORT | (2<<8))
      	CONSTRAINT_CHECK        = C.SQLITE_CONSTRAINT_CHECK        // (SQLITE_CONSTRAINT | (1<<8))
      	CONSTRAINT_COMMITHOOK   = C.SQLITE_CONSTRAINT_COMMITHOOK   // (SQLITE_CONSTRAINT | (2<<8))
      	CONSTRAINT_FOREIGNKEY   = C.SQLITE_CONSTRAINT_FOREIGNKEY   // (SQLITE_CONSTRAINT | (3<<8))
      	CONSTRAINT_FUNCTION     = C.SQLITE_CONSTRAINT_FUNCTION     // (SQLITE_CONSTRAINT | (4<<8))
      	CONSTRAINT_NOTNULL      = C.SQLITE_CONSTRAINT_NOTNULL      // (SQLITE_CONSTRAINT | (5<<8))
      	CONSTRAINT_PRIMARYKEY   = C.SQLITE_CONSTRAINT_PRIMARYKEY   // (SQLITE_CONSTRAINT | (6<<8))
      	CONSTRAINT_TRIGGER      = C.SQLITE_CONSTRAINT_TRIGGER      // (SQLITE_CONSTRAINT | (7<<8))
      	CONSTRAINT_UNIQUE       = C.SQLITE_CONSTRAINT_UNIQUE       // (SQLITE_CONSTRAINT | (8<<8))
      	CONSTRAINT_VTAB         = C.SQLITE_CONSTRAINT_VTAB         // (SQLITE_CONSTRAINT | (9<<8))
      	CONSTRAINT_ROWID        = C.SQLITE_CONSTRAINT_ROWID        // (SQLITE_CONSTRAINT |(10<<8))
      	NOTICE_RECOVER_WAL      = C.SQLITE_NOTICE_RECOVER_WAL      // (SQLITE_NOTICE | (1<<8))
      	NOTICE_RECOVER_ROLLBACK = C.SQLITE_NOTICE_RECOVER_ROLLBACK // (SQLITE_NOTICE | (2<<8))
      	WARNING_AUTOINDEX       = C.SQLITE_WARNING_AUTOINDEX       // (SQLITE_WARNING | (1<<8))
      )

        Extended result codes returned by the SQLite API. Extended result codes are enabled by default for all new Conn objects. Use Error.Code()&0xFF to convert an extended code to a general one. [http://www.sqlite.org/c3ref/c_abort_rollback.html]

        View Source
        const (
        	CREATE_INDEX        = C.SQLITE_CREATE_INDEX        // 1
        	CREATE_TABLE        = C.SQLITE_CREATE_TABLE        // 2
        	CREATE_TEMP_INDEX   = C.SQLITE_CREATE_TEMP_INDEX   // 3
        	CREATE_TEMP_TABLE   = C.SQLITE_CREATE_TEMP_TABLE   // 4
        	CREATE_TEMP_TRIGGER = C.SQLITE_CREATE_TEMP_TRIGGER // 5
        	CREATE_TEMP_VIEW    = C.SQLITE_CREATE_TEMP_VIEW    // 6
        	CREATE_TRIGGER      = C.SQLITE_CREATE_TRIGGER      // 7
        	CREATE_VIEW         = C.SQLITE_CREATE_VIEW         // 8
        	DELETE              = C.SQLITE_DELETE              // 9
        	DROP_INDEX          = C.SQLITE_DROP_INDEX          // 10
        	DROP_TABLE          = C.SQLITE_DROP_TABLE          // 11
        	DROP_TEMP_INDEX     = C.SQLITE_DROP_TEMP_INDEX     // 12
        	DROP_TEMP_TABLE     = C.SQLITE_DROP_TEMP_TABLE     // 13
        	DROP_TEMP_TRIGGER   = C.SQLITE_DROP_TEMP_TRIGGER   // 14
        	DROP_TEMP_VIEW      = C.SQLITE_DROP_TEMP_VIEW      // 15
        	DROP_TRIGGER        = C.SQLITE_DROP_TRIGGER        // 16
        	DROP_VIEW           = C.SQLITE_DROP_VIEW           // 17
        	INSERT              = C.SQLITE_INSERT              // 18
        	PRAGMA              = C.SQLITE_PRAGMA              // 19
        	READ                = C.SQLITE_READ                // 20
        	SELECT              = C.SQLITE_SELECT              // 21
        	TRANSACTION         = C.SQLITE_TRANSACTION         // 22
        	UPDATE              = C.SQLITE_UPDATE              // 23
        	ATTACH              = C.SQLITE_ATTACH              // 24
        	DETACH              = C.SQLITE_DETACH              // 25
        	ALTER_TABLE         = C.SQLITE_ALTER_TABLE         // 26
        	REINDEX             = C.SQLITE_REINDEX             // 27
        	ANALYZE             = C.SQLITE_ANALYZE             // 28
        	CREATE_VTABLE       = C.SQLITE_CREATE_VTABLE       // 29
        	DROP_VTABLE         = C.SQLITE_DROP_VTABLE         // 30
        	FUNCTION            = C.SQLITE_FUNCTION            // 31
        	SAVEPOINT           = C.SQLITE_SAVEPOINT           // 32
        	RECURSIVE           = C.SQLITE_RECURSIVE           // 33
        )

          Codes used by SQLite to indicate the operation type when invoking authorizer and row update callbacks. [http://www.sqlite.org/c3ref/c_alter_table.html]

          View Source
          const (
          	STATUS_MEMORY_USED        = C.SQLITE_STATUS_MEMORY_USED        // 0
          	STATUS_PAGECACHE_USED     = C.SQLITE_STATUS_PAGECACHE_USED     // 1
          	STATUS_PAGECACHE_OVERFLOW = C.SQLITE_STATUS_PAGECACHE_OVERFLOW // 2
          	STATUS_SCRATCH_USED       = C.SQLITE_STATUS_SCRATCH_USED       // 3
          	STATUS_SCRATCH_OVERFLOW   = C.SQLITE_STATUS_SCRATCH_OVERFLOW   // 4
          	STATUS_MALLOC_SIZE        = C.SQLITE_STATUS_MALLOC_SIZE        // 5
          	STATUS_PARSER_STACK       = C.SQLITE_STATUS_PARSER_STACK       // 6
          	STATUS_PAGECACHE_SIZE     = C.SQLITE_STATUS_PAGECACHE_SIZE     // 7
          	STATUS_SCRATCH_SIZE       = C.SQLITE_STATUS_SCRATCH_SIZE       // 8
          	STATUS_MALLOC_COUNT       = C.SQLITE_STATUS_MALLOC_COUNT       // 9
          )

            Core SQLite performance counters that can be queried with Status. [http://www.sqlite.org/c3ref/c_status_malloc_count.html]

            View Source
            const (
            	DBSTATUS_LOOKASIDE_USED      = C.SQLITE_DBSTATUS_LOOKASIDE_USED      // 0
            	DBSTATUS_CACHE_USED          = C.SQLITE_DBSTATUS_CACHE_USED          // 1
            	DBSTATUS_SCHEMA_USED         = C.SQLITE_DBSTATUS_SCHEMA_USED         // 2
            	DBSTATUS_STMT_USED           = C.SQLITE_DBSTATUS_STMT_USED           // 3
            	DBSTATUS_LOOKASIDE_HIT       = C.SQLITE_DBSTATUS_LOOKASIDE_HIT       // 4
            	DBSTATUS_LOOKASIDE_MISS_SIZE = C.SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE // 5
            	DBSTATUS_LOOKASIDE_MISS_FULL = C.SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL // 6
            	DBSTATUS_CACHE_HIT           = C.SQLITE_DBSTATUS_CACHE_HIT           // 7
            	DBSTATUS_CACHE_MISS          = C.SQLITE_DBSTATUS_CACHE_MISS          // 8
            	DBSTATUS_CACHE_WRITE         = C.SQLITE_DBSTATUS_CACHE_WRITE         // 9
            	DBSTATUS_DEFERRED_FKS        = C.SQLITE_DBSTATUS_DEFERRED_FKS        // 10
            )

              Connection performance counters that can be queried with Conn.Status. [http://www.sqlite.org/c3ref/c_dbstatus_options.html]

              View Source
              const (
              	STMTSTATUS_FULLSCAN_STEP = C.SQLITE_STMTSTATUS_FULLSCAN_STEP // 1
              	STMTSTATUS_SORT          = C.SQLITE_STMTSTATUS_SORT          // 2
              	STMTSTATUS_AUTOINDEX     = C.SQLITE_STMTSTATUS_AUTOINDEX     // 3
              	STMTSTATUS_VM_STEP       = C.SQLITE_STMTSTATUS_VM_STEP       // 4
              )

                Statement performance counters that can be queried with Stmt.Status. [http://www.sqlite.org/c3ref/c_stmtstatus_counter.html]

                View Source
                const (
                	LIMIT_LENGTH              = C.SQLITE_LIMIT_LENGTH              // 0
                	LIMIT_SQL_LENGTH          = C.SQLITE_LIMIT_SQL_LENGTH          // 1
                	LIMIT_COLUMN              = C.SQLITE_LIMIT_COLUMN              // 2
                	LIMIT_EXPR_DEPTH          = C.SQLITE_LIMIT_EXPR_DEPTH          // 3
                	LIMIT_COMPOUND_SELECT     = C.SQLITE_LIMIT_COMPOUND_SELECT     // 4
                	LIMIT_VDBE_OP             = C.SQLITE_LIMIT_VDBE_OP             // 5
                	LIMIT_FUNCTION_ARG        = C.SQLITE_LIMIT_FUNCTION_ARG        // 6
                	LIMIT_ATTACHED            = C.SQLITE_LIMIT_ATTACHED            // 7
                	LIMIT_LIKE_PATTERN_LENGTH = C.SQLITE_LIMIT_LIKE_PATTERN_LENGTH // 8
                	LIMIT_VARIABLE_NUMBER     = C.SQLITE_LIMIT_VARIABLE_NUMBER     // 9
                	LIMIT_TRIGGER_DEPTH       = C.SQLITE_LIMIT_TRIGGER_DEPTH       // 10
                )

                  Per-connection limits that can be queried and changed with Conn.Limit. [http://www.sqlite.org/c3ref/c_limit_attached.html]

                  Variables

                  View Source
                  var (
                  	ErrBadConn   = &Error{MISUSE, "closed or invalid connection"}
                  	ErrBadStmt   = &Error{MISUSE, "closed or invalid statement"}
                  	ErrBadIO     = &Error{MISUSE, "closed or invalid incremental I/O operation"}
                  	ErrBadBackup = &Error{MISUSE, "closed or invalid backup operation"}
                  )

                    Errors returned for access attempts to closed or invalid objects.

                    View Source
                    var ErrBlobFull = &Error{ERROR, "incremental write failed, no space left"}

                      ErrBlobFull is returned by BlobIO.Write when there isn't enough space left to write the provided bytes.

                      Functions

                      func Complete

                      func Complete(sql string) bool

                        Complete returns true if sql appears to contain a complete statement that is ready to be parsed. This does not validate the statement syntax. [http://www.sqlite.org/c3ref/complete.html]

                        func Print

                        func Print(s *Stmt) error

                          Print prints out all rows returned by a query. This function is intended as a debugging aid and may be removed or altered in the future. Do not use it in production applications.

                          func RegisterCodec

                          func RegisterCodec(name string, f CodecFunc)

                            RegisterCodec adds a new codec to the internal registry. Function f will be called when a key in the format "<name>:<...>" is provided to an attached database.

                            func ReleaseMemory

                            func ReleaseMemory(n int) int

                              ReleaseMemory attempts to free n bytes of heap memory by deallocating non-essential memory held by the SQLite library. It returns the number of bytes actually freed.

                              This function is currently a no-op because SQLite is not compiled with the SQLITE_ENABLE_MEMORY_MANAGEMENT option. [http://www.sqlite.org/c3ref/release_memory.html]

                              func SingleThread

                              func SingleThread() bool

                                SingleThread returns true if the SQLite library was compiled with -DSQLITE_THREADSAFE=0. In this threading mode all mutex code is omitted and the package becomes unsafe for concurrent access, even to separate database connections.

                                The SQLite source that's part of this package is compiled with -DSQLITE_THREADSAFE=2, so this function should always return false. It is kept for backward compatibility when dynamic linking was supported in Go 1.0. [http://www.sqlite.org/threadsafe.html]

                                func SoftHeapLimit

                                func SoftHeapLimit(n int64) int64

                                  SoftHeapLimit sets and/or queries the soft limit on the amount of heap memory that may be allocated by SQLite. A negative value for n keeps the current limit, while 0 removes the limit. The previous limit value is returned, with negative values indicating an error. [http://www.sqlite.org/c3ref/soft_heap_limit64.html]

                                  func SourceId

                                  func SourceId() string

                                    SourceId returns the check-in identifier of SQLite within its configuration management system. [http://www.sqlite.org/c3ref/c_source_id.html]

                                    func Status

                                    func Status(op int, reset bool) (cur, peak int, err error)

                                      Status returns the current and peak values of a core performance counter, specified by one of the STATUS constants. If reset is true, the peak value is reset back down to the current value after retrieval. [http://www.sqlite.org/c3ref/status.html]

                                      func Version

                                      func Version() string

                                        Version returns the SQLite version as a string in the format "X.Y.Z[.N]". [http://www.sqlite.org/c3ref/libversion.html]

                                        func VersionNum

                                        func VersionNum() int

                                          VersionNum returns the SQLite version as an integer in the format X*1000000 + Y*1000 + Z, where X is the major version, Y is the minor version, and Z is the release number.

                                          Types

                                          type Backup

                                          type Backup struct {
                                          	// contains filtered or unexported fields
                                          }

                                            Backup is a handle to an online backup operation between two databases. [http://www.sqlite.org/c3ref/backup.html]

                                            func (*Backup) Close

                                            func (b *Backup) Close() error

                                              Close releases all resources associated with the backup operation. It is safe to call this method prior to backup completion to abort the operation. [http://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupfinish]

                                              func (*Backup) Conn

                                              func (b *Backup) Conn() (src, dst *Conn)

                                                Conn returns the source and destination connections that are used by this backup operation. The destination connection must not be used until the backup operation is closed.

                                                func (*Backup) Progress

                                                func (b *Backup) Progress() (remaining, total int)

                                                  Progress returns the number of pages that still need to be backed up and the total number of pages in the source database. The values are updated after each call to Step and are reset to 0 after the backup is closed. The total number of pages may change if the source database is modified during the backup operation. [http://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupremaining]

                                                  func (*Backup) Step

                                                  func (b *Backup) Step(n int) error

                                                    Step copies up to n pages to the destination database. If n is negative, all remaining pages are copied. io.EOF is returned upon successful backup completion. [http://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupstep]

                                                    type BlobIO

                                                    type BlobIO struct {
                                                    	// contains filtered or unexported fields
                                                    }

                                                      BlobIO is a handle to a single BLOB (binary large object) or TEXT value opened for incremental I/O. This allows the value to be treated as a file for reading and writing. The value length cannot be changed using this API; use an UPDATE statement for that. The recommended way of allocating space for a BLOB is to use the ZeroBlob type or the zeroblob() SQL function. [http://www.sqlite.org/c3ref/blob.html]

                                                      func (*BlobIO) Close

                                                      func (b *BlobIO) Close() error

                                                        Close releases all resources associated with the incremental I/O operation. It is important to check the error returned by this method, since disk I/O and other types of errors may not be reported until the changes are actually committed to the database. [http://www.sqlite.org/c3ref/blob_close.html]

                                                        func (*BlobIO) Conn

                                                        func (b *BlobIO) Conn() *Conn

                                                          Conn returns the connection that that created this incremental I/O operation.

                                                          func (*BlobIO) Len

                                                          func (b *BlobIO) Len() int

                                                            Len returns the length of the BLOB/TEXT value in bytes. It is not possible to read/write/seek beyond this length. The length changes to 0 if the I/O handle expires due to an update of any column in the same row. This condition is indicated by an ABORT error code returned from Read or Write. An expired handle is closed automatically and cannot be reopened. Any writes that occurred before the abort are not rolled back. [http://www.sqlite.org/c3ref/blob_bytes.html]

                                                            func (*BlobIO) Read

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

                                                              Read implements the io.Reader interface. [http://www.sqlite.org/c3ref/blob_read.html]

                                                              func (*BlobIO) Reopen

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

                                                                Reopen closes the current value and opens another one in the same column, specified by its ROWID. If an error is encountered, the I/O handle becomes unusable and is automatically closed. [http://www.sqlite.org/c3ref/blob_reopen.html]

                                                                func (*BlobIO) Row

                                                                func (b *BlobIO) Row() int64

                                                                  Row returns the ROWID of the row containing the BLOB/TEXT value.

                                                                  func (*BlobIO) Seek

                                                                  func (b *BlobIO) Seek(offset int64, whence int) (ret int64, err error)

                                                                    Seek implements the io.Seeker interface.

                                                                    func (*BlobIO) Write

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

                                                                      Write implements the io.Writer interface. The number of bytes written is always either 0 or len(p). ErrBlobFull is returned if there isn't enough space left to write all of p. [http://www.sqlite.org/c3ref/blob_write.html]

                                                                      type BusyFunc

                                                                      type BusyFunc func(count int) (retry bool)

                                                                        BusyFunc is a callback function invoked by SQLite when it is unable to acquire a lock on a table. Count is the number of times that the callback has been invoked for this locking event so far. If the function returns false, then the operation is aborted. Otherwise, the function should block for a while before returning true and letting SQLite make another locking attempt.

                                                                        type Codec

                                                                        type Codec interface {
                                                                        	// Reserve returns the number of bytes that should be reserved for the codec
                                                                        	// at the end of each page. The upper limit is 255 (32 if the page size is
                                                                        	// 512). Returning -1 leaves the current value unchanged.
                                                                        	Reserve() int
                                                                        
                                                                        	// Resize is called when the codec is first attached to the pager and for
                                                                        	// all subsequent page size changes. It can be used to allocate the encode
                                                                        	// buffer.
                                                                        	Resize(pageSize, reserve int)
                                                                        
                                                                        	// Encode returns an encoded copy of a page. The data outside of the reserve
                                                                        	// area in the original page must not be modified. The codec can either copy
                                                                        	// this data into a buffer for encoding or return the original page without
                                                                        	// making any changes. Bytes 16 through 23 of page 1 cannot be encoded. Any
                                                                        	// non-nil error will be interpreted by SQLite as a NOMEM condition. This is
                                                                        	// a limitation of underlying C API.
                                                                        	Encode(page []byte, pageNum uint32, op int) ([]byte, *Error)
                                                                        
                                                                        	// Decode decodes the page in-place, but it may use the encode buffer as
                                                                        	// scratch space. Bytes 16 through 23 of page 1 must be left at their
                                                                        	// original values. Any non-nil error will be interpreted by SQLite as a
                                                                        	// NOMEM condition. This is a limitation of underlying C API.
                                                                        	Decode(page []byte, pageNum uint32, op int) *Error
                                                                        
                                                                        	// Key returns the original key that was used to initialize the codec. Some
                                                                        	// implementations may be better off returning nil or a fake value. Search
                                                                        	// lib/sqlite3.c for "sqlite3CodecGetKey" to see how the key is used.
                                                                        	Key() []byte
                                                                        
                                                                        	// Free releases codec resources when the pager is destroyed or when the
                                                                        	// codec attachment fails.
                                                                        	Free()
                                                                        }

                                                                          Codec is the interface used to encode/decode database and journal pages as they are written to and read from the disk.

                                                                          The op value passed to Encode and Decode methods identifies the operation being performed. It is undocumented and changed meanings over time since the codec API was first introduced in 2004. It is believed to be a bitmask of the following values:

                                                                          1 = journal page, not set for WAL, always set when decoding
                                                                          2 = disk I/O, always set
                                                                          4 = encode
                                                                          

                                                                          In the current implementation, op is always 3 when decoding, 6 when encoding for the database file or the WAL, and 7 when encoding for the journal. Search lib/sqlite3.c for "CODEC1" and "CODEC2" for more information.

                                                                          type CodecCtx

                                                                          type CodecCtx struct {
                                                                          	Path     string // Full path to the database file
                                                                          	Name     string // Database name as it is known to SQLite (e.g. "main")
                                                                          	PageSize int    // Current page size in bytes
                                                                          	Reserve  int    // Current number of bytes reserved in each page
                                                                          	Fixed    bool   // True if the PageSize and Reserve values cannot be changed
                                                                          }

                                                                            CodecCtx describes the database to which a codec is being attached.

                                                                            type CodecFunc

                                                                            type CodecFunc func(ctx *CodecCtx, key []byte) (Codec, *Error)

                                                                              CodecFunc is a codec initialization function registered for a specific key prefix via RegisterCodec. It is called when a key with a matching prefix is specified for an attached database. It returns the Codec implementation that should be used to encode and decode all database and journal pages. Returning (nil, nil) disables the codec.

                                                                              type CommitFunc

                                                                              type CommitFunc func() (abort bool)

                                                                                CommitFunc is a callback function invoked by SQLite before a transaction is committed. If the function returns true, the transaction is rolled back.

                                                                                type Conn

                                                                                type Conn struct {
                                                                                	// contains filtered or unexported fields
                                                                                }

                                                                                  Conn is a connection handle, which may have multiple databases attached to it by using the ATTACH SQL statement. [http://www.sqlite.org/c3ref/sqlite3.html]

                                                                                  func Open

                                                                                  func Open(name string) (*Conn, error)

                                                                                    Open creates a new connection to a SQLite database. The name can be 1) a path to a file, which is created if it does not exist, 2) a URI using the syntax described at http://www.sqlite.org/uri.html, 3) the string ":memory:", which creates a temporary in-memory database, or 4) an empty string, which creates a temporary on-disk database (deleted when closed) in the directory returned by os.TempDir(). [http://www.sqlite.org/c3ref/open.html]

                                                                                    func (*Conn) AutoCommit

                                                                                    func (c *Conn) AutoCommit() bool

                                                                                      AutoCommit returns true if the database connection is in auto-commit mode (i.e. outside of an explicit transaction started by BEGIN). [http://www.sqlite.org/c3ref/get_autocommit.html]

                                                                                      func (*Conn) Backup

                                                                                      func (c *Conn) Backup(srcName string, dst *Conn, dstName string) (*Backup, error)

                                                                                        Backup starts an online database backup of c.srcName into dst.dstName. Connections c and dst must be distinct. All existing contents of the destination database are overwritten.

                                                                                        A read lock is acquired on the source database only while it is being read during a call to Backup.Step. The source connection may be used for other purposes between these calls. The destination connection must not be used for anything until the backup is closed. [http://www.sqlite.org/backup.html]

                                                                                        func (*Conn) Begin

                                                                                        func (c *Conn) Begin() error

                                                                                          Begin starts a new deferred transaction. Use c.Exec("BEGIN...") to start an immediate or an exclusive transaction. [http://www.sqlite.org/lang_transaction.html]

                                                                                          func (*Conn) BlobIO

                                                                                          func (c *Conn) BlobIO(db, tbl, col string, row int64, rw bool) (*BlobIO, error)

                                                                                            BlobIO opens a BLOB or TEXT value for incremental I/O, allowing the value to be treated as a file for reading and/or writing. The value is located as if by the following query:

                                                                                            SELECT col FROM db.tbl WHERE rowid=row
                                                                                            

                                                                                            If rw is true, the value is opened with read-write access, otherwise it is read-only. It is not possible to open a column that is part of an index or primary key for writing. If foreign key constraints are enabled, it is not possible to open a column that is part of a child key for writing. [http://www.sqlite.org/c3ref/blob_open.html]

                                                                                            func (*Conn) BusyFunc

                                                                                            func (c *Conn) BusyFunc(f BusyFunc) (prev BusyFunc)

                                                                                              BusyFunc registers a function that is invoked by SQLite when it is unable to acquire a lock on a table. It returns the previous busy handler, if any. The function f should return true to make another lock acquisition attempt, or false to let the operation fail with BUSY or IOERR_BLOCKED error code. [http://www.sqlite.org/c3ref/busy_handler.html]

                                                                                              func (*Conn) BusyTimeout

                                                                                              func (c *Conn) BusyTimeout(d time.Duration) (prev BusyFunc)

                                                                                                BusyTimeout enables the built-in busy handler, which retries the table locking operation for the specified duration before aborting. It returns the callback function that was previously registered with Conn.BusyFunc, if any. The busy handler is disabled if d is negative or zero. [http://www.sqlite.org/c3ref/busy_timeout.html]

                                                                                                func (*Conn) Close

                                                                                                func (c *Conn) Close() error

                                                                                                  Close releases all resources associated with the connection. If any prepared statements, incremental I/O operations, or backup operations are still active, the connection becomes an unusable "zombie" and is closed after all remaining statements and operations are destroyed. A BUSY error code is returned if the connection is left in this "zombie" status, which may indicate a programming error where some previously allocated resource is not properly released. [http://www.sqlite.org/c3ref/close.html]

                                                                                                  func (*Conn) Commit

                                                                                                  func (c *Conn) Commit() error

                                                                                                    Commit saves all changes made within a transaction to the database.

                                                                                                    func (*Conn) CommitFunc

                                                                                                    func (c *Conn) CommitFunc(f CommitFunc) (prev CommitFunc)

                                                                                                      CommitFunc registers a function that is invoked by SQLite before a transaction is committed. It returns the previous commit handler, if any. If the function f returns true, the transaction is rolled back instead, causing the rollback handler to be invoked, if one is registered. [http://www.sqlite.org/c3ref/commit_hook.html]

                                                                                                      func (*Conn) Exec

                                                                                                      func (c *Conn) Exec(sql string, args ...interface{}) error

                                                                                                        Exec is a convenience method for executing one or more statements in sql. Arguments may be specified either as a list of unnamed interface{} values or as a single NamedArgs map. In unnamed mode, each statement consumes the required number of values from args. For example:

                                                                                                        c.Exec("UPDATE x SET a=?; UPDATE x SET b=?", 1, 2) // is executed as:
                                                                                                        // UPDATE x SET a=1
                                                                                                        // UPDATE x SET b=2
                                                                                                        

                                                                                                        With NamedArgs, the entire map is passed to every statement in sql and unreferenced names are ignored. The following example is identical to the previous one:

                                                                                                        args := NamedArgs{"$a": 1, "$b": 2}
                                                                                                        c.Exec("UPDATE x SET a=$a; UPDATE x SET b=$b", args)
                                                                                                        

                                                                                                        Without any extra arguments, the statements in sql are executed by a single call to sqlite3_exec. [http://www.sqlite.org/c3ref/exec.html]

                                                                                                        func (*Conn) Interrupt

                                                                                                        func (c *Conn) Interrupt()

                                                                                                          Interrupt causes any pending database operation to abort and return at its earliest opportunity. It is safe to call this method from a goroutine different from the one that is currently running the database operation, but it is not safe to call this method on a connection that might close before the call returns. [http://www.sqlite.org/c3ref/interrupt.html]

                                                                                                          func (*Conn) Key

                                                                                                          func (c *Conn) Key(db string, key []byte) error

                                                                                                            Key provides a codec key to an attached database. This method should be called right after opening the connection.

                                                                                                            func (*Conn) LastInsertId

                                                                                                            func (c *Conn) LastInsertId() int64

                                                                                                              LastInsertId returns the ROWID of the most recent successful INSERT statement. [http://www.sqlite.org/c3ref/last_insert_rowid.html]

                                                                                                              func (*Conn) Limit

                                                                                                              func (c *Conn) Limit(id, value int) (prev int)

                                                                                                                Limit changes a per-connection resource usage or performance limit, specified by one of the LIMIT constants, returning its previous value. If the new value is negative, the limit is left unchanged and its current value is returned. [http://www.sqlite.org/c3ref/limit.html]

                                                                                                                func (*Conn) Path

                                                                                                                func (c *Conn) Path(db string) string

                                                                                                                  Path returns the full file path of an attached database. An empty string is returned for temporary databases. [http://www.sqlite.org/c3ref/db_filename.html]

                                                                                                                  func (*Conn) Prepare

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

                                                                                                                    Prepare compiles the first statement in sql. Any remaining text after the first statement is saved in Stmt.Tail. [http://www.sqlite.org/c3ref/prepare.html]

                                                                                                                    func (*Conn) Query

                                                                                                                    func (c *Conn) Query(sql string, args ...interface{}) (*Stmt, error)

                                                                                                                      Query is a convenience method for executing the first query in sql. It returns either a prepared statement ready for scanning or an error, which will be io.EOF if the query did not return any rows.

                                                                                                                      func (*Conn) Rekey

                                                                                                                      func (c *Conn) Rekey(db string, key []byte) error

                                                                                                                        Rekey changes the codec key for an attached database. This is not currently implemented for Go codecs.

                                                                                                                        func (*Conn) Rollback

                                                                                                                        func (c *Conn) Rollback() error

                                                                                                                          Rollback aborts the current transaction without saving any changes.

                                                                                                                          func (*Conn) RollbackFunc

                                                                                                                          func (c *Conn) RollbackFunc(f RollbackFunc) (prev RollbackFunc)

                                                                                                                            RollbackFunc registers a function that is invoked by SQLite when a transaction is rolled back. It returns the previous rollback handler, if any. [http://www.sqlite.org/c3ref/commit_hook.html]

                                                                                                                            func (*Conn) RowsAffected

                                                                                                                            func (c *Conn) RowsAffected() int

                                                                                                                              RowsAffected returns the number of rows that were changed, inserted, or deleted by the most recent statement. Auxiliary changes caused by triggers or foreign key actions are not counted. [http://www.sqlite.org/c3ref/changes.html]

                                                                                                                              func (*Conn) Status

                                                                                                                              func (c *Conn) Status(op int, reset bool) (cur, peak int, err error)

                                                                                                                                Status returns the current and peak values of a connection performance counter, specified by one of the DBSTATUS constants. If reset is true, the peak value is reset back down to the current value after retrieval. [http://www.sqlite.org/c3ref/db_status.html]

                                                                                                                                func (*Conn) TotalRowsAffected

                                                                                                                                func (c *Conn) TotalRowsAffected() int

                                                                                                                                  TotalRowsAffected returns the number of rows that were changed, inserted, or deleted since the database connection was opened, including changes caused by trigger and foreign key actions. [http://www.sqlite.org/c3ref/total_changes.html]

                                                                                                                                  func (*Conn) UpdateFunc

                                                                                                                                  func (c *Conn) UpdateFunc(f UpdateFunc) (prev UpdateFunc)

                                                                                                                                    UpdateFunc registers a function that is invoked by SQLite when a row is updated, inserted, or deleted. It returns the previous update handler, if any. [http://www.sqlite.org/c3ref/update_hook.html]

                                                                                                                                    type Driver

                                                                                                                                    type Driver string

                                                                                                                                      Driver implements the interface required by database/sql.

                                                                                                                                      func (Driver) Open

                                                                                                                                      func (Driver) Open(name string) (driver.Conn, error)

                                                                                                                                      type Error

                                                                                                                                      type Error struct {
                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                      }

                                                                                                                                        Error is returned for all SQLite API result codes other than OK, ROW, and DONE.

                                                                                                                                        func NewError

                                                                                                                                        func NewError(rc int, msg string) *Error

                                                                                                                                          NewError creates a new Error instance using the specified SQLite result code and error message.

                                                                                                                                          func (*Error) Code

                                                                                                                                          func (err *Error) Code() int

                                                                                                                                            Code returns the SQLite extended result code.

                                                                                                                                            func (*Error) Error

                                                                                                                                            func (err *Error) Error() string

                                                                                                                                              Error implements the error interface.

                                                                                                                                              type NamedArgs

                                                                                                                                              type NamedArgs map[string]interface{}

                                                                                                                                                NamedArgs is a name/value map of arguments passed to a prepared statement that uses ?NNN, :AAA, @AAA, and/or $AAA parameter formats. Name matching is case-sensitive and the prefix character (one of [?:@$]) must be included in the name. Names that are missing from the map are treated as NULL. Names that are not used in the prepared statement are ignored.

                                                                                                                                                It is not possible to mix named and anonymous ("?") parameters in the same statement. [http://www.sqlite.org/lang_expr.html#varparam]

                                                                                                                                                type RawBytes

                                                                                                                                                type RawBytes []byte

                                                                                                                                                  RawString and RawBytes are special string and []byte types that may be used for database input and output without the cost of an extra copy operation.

                                                                                                                                                  When used as an argument to a statement, the contents are bound using SQLITE_STATIC instead of SQLITE_TRANSIENT flag. This requires the contents to remain valid and unmodified until the end of statement execution. In particular, the caller must keep a reference to the value to prevent it from being garbage collected.

                                                                                                                                                  When used for retrieving query output, the internal string/[]byte pointer is set to reference memory belonging to SQLite. The memory remains valid until another method is called on the Stmt object and should not be modified.

                                                                                                                                                  func (RawBytes) Copy

                                                                                                                                                  func (b RawBytes) Copy() []byte

                                                                                                                                                    Copy returns a Go-managed copy of b.

                                                                                                                                                    type RawString

                                                                                                                                                    type RawString string

                                                                                                                                                      RawString and RawBytes are special string and []byte types that may be used for database input and output without the cost of an extra copy operation.

                                                                                                                                                      When used as an argument to a statement, the contents are bound using SQLITE_STATIC instead of SQLITE_TRANSIENT flag. This requires the contents to remain valid and unmodified until the end of statement execution. In particular, the caller must keep a reference to the value to prevent it from being garbage collected.

                                                                                                                                                      When used for retrieving query output, the internal string/[]byte pointer is set to reference memory belonging to SQLite. The memory remains valid until another method is called on the Stmt object and should not be modified.

                                                                                                                                                      func (RawString) Copy

                                                                                                                                                      func (s RawString) Copy() string

                                                                                                                                                        Copy returns a Go-managed copy of s.

                                                                                                                                                        type RollbackFunc

                                                                                                                                                        type RollbackFunc func()

                                                                                                                                                          RollbackFunc is a callback function invoked by SQLite when a transaction is rolled back.

                                                                                                                                                          type RowMap

                                                                                                                                                          type RowMap map[string]interface{}

                                                                                                                                                            RowMap may be passed as the last (or only) argument to Stmt.Scan to create a map of all remaining column/value pairs in the current row. The map is not cleared before being populated with new column values. Assignment is performed in left-to-right column order, and values may be overwritten if the query returns two or more columns with identical names.

                                                                                                                                                            type Stmt

                                                                                                                                                            type Stmt struct {
                                                                                                                                                            	Tail string // Uncompiled portion of the SQL string passed to Conn.Prepare
                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                            }

                                                                                                                                                              Stmt is a prepared statement handle.

                                                                                                                                                              SQLite automatically recompiles prepared statements when the database schema changes. A query like "SELECT * FROM x" may return a different number of columns from one execution to the next if the table is altered. The recompilation, if required, only happens at the start of execution (during a call to Exec or Query). Statements that are already running (Busy() == true) are not recompiled. Thus, the safest way of obtaining column information is to call Exec or Query first, followed by NumColumns, Columns, DeclTypes, etc. [http://www.sqlite.org/c3ref/stmt.html]

                                                                                                                                                              func (*Stmt) Busy

                                                                                                                                                              func (s *Stmt) Busy() bool

                                                                                                                                                                Busy returns true if the prepared statement is in the middle of execution with a row available for scanning. It is not necessary to reset a busy statement before making another call to Exec or Query.

                                                                                                                                                                func (*Stmt) Close

                                                                                                                                                                func (s *Stmt) Close() error

                                                                                                                                                                  Close releases all resources associated with the prepared statement. This method can be called at any point in the statement's life cycle. [http://www.sqlite.org/c3ref/finalize.html]

                                                                                                                                                                  func (*Stmt) Columns

                                                                                                                                                                  func (s *Stmt) Columns() []string

                                                                                                                                                                    Columns returns the names of columns produced by the prepared statement. [http://www.sqlite.org/c3ref/column_name.html]

                                                                                                                                                                    func (*Stmt) Conn

                                                                                                                                                                    func (s *Stmt) Conn() *Conn

                                                                                                                                                                      Conn returns the connection that that created this prepared statement.

                                                                                                                                                                      func (*Stmt) DataTypes

                                                                                                                                                                      func (s *Stmt) DataTypes() []uint8

                                                                                                                                                                        DataTypes returns the data type codes of columns in the current row. Possible data types are INTEGER, FLOAT, TEXT, BLOB, and NULL. These represent the actual storage classes used by SQLite to store each value before any conversion. The returned slice should not be modified. [http://www.sqlite.org/c3ref/column_blob.html]

                                                                                                                                                                        func (*Stmt) DeclTypes

                                                                                                                                                                        func (s *Stmt) DeclTypes() []string

                                                                                                                                                                          DeclTypes returns the type declarations of columns produced by the prepared statement. The type declarations are normalized to upper case. [http://www.sqlite.org/c3ref/column_decltype.html]

                                                                                                                                                                          func (*Stmt) Exec

                                                                                                                                                                          func (s *Stmt) Exec(args ...interface{}) error

                                                                                                                                                                            Exec executes and resets the prepared statement. No rows are returned. [http://www.sqlite.org/c3ref/step.html]

                                                                                                                                                                            func (*Stmt) Next

                                                                                                                                                                            func (s *Stmt) Next() error

                                                                                                                                                                              Next makes the next row available for scanning. io.EOF is returned and the statement is reset if no more rows are available.

                                                                                                                                                                              func (*Stmt) NumColumns

                                                                                                                                                                              func (s *Stmt) NumColumns() int

                                                                                                                                                                                NumColumns returns the number of columns produced by the prepared statement. [http://www.sqlite.org/c3ref/column_count.html]

                                                                                                                                                                                func (*Stmt) NumParams

                                                                                                                                                                                func (s *Stmt) NumParams() int

                                                                                                                                                                                  NumParams returns the number of bound parameters in the prepared statement. This is also the number of arguments required for calling Exec or Query without a NamedArgs map. [http://www.sqlite.org/c3ref/bind_parameter_count.html]

                                                                                                                                                                                  func (*Stmt) Params

                                                                                                                                                                                  func (s *Stmt) Params() []string

                                                                                                                                                                                    Params returns the names of bound parameters in the prepared statement. Nil is returned if the statement does not use named parameters. [http://www.sqlite.org/c3ref/bind_parameter_name.html]

                                                                                                                                                                                    func (*Stmt) Query

                                                                                                                                                                                    func (s *Stmt) Query(args ...interface{}) error

                                                                                                                                                                                      Query executes the prepared statement and makes the first returned row available for scanning. io.EOF is returned and the statement is reset if the query does not return any rows.

                                                                                                                                                                                      func (*Stmt) ReadOnly

                                                                                                                                                                                      func (s *Stmt) ReadOnly() bool

                                                                                                                                                                                        ReadOnly returns true if the prepared statement makes no direct changes to the content of the database file. [http://www.sqlite.org/c3ref/stmt_readonly.html]

                                                                                                                                                                                        func (*Stmt) Reset

                                                                                                                                                                                        func (s *Stmt) Reset()

                                                                                                                                                                                          Reset returns the prepared statement to its initial state, ready to be re-executed. This should be done when the remaining rows returned by a query are not needed, which releases some resources that would otherwise persist until the next call to Exec or Query. [http://www.sqlite.org/c3ref/reset.html]

                                                                                                                                                                                          func (*Stmt) Scan

                                                                                                                                                                                          func (s *Stmt) Scan(dst ...interface{}) error

                                                                                                                                                                                            Scan retrieves data from the current row, storing successive column values into successive arguments. If the last argument is an instance of RowMap, then all remaining column/value pairs are assigned into the map. The same row may be scanned multiple times. Nil arguments are silently skipped. [http://www.sqlite.org/c3ref/column_blob.html]

                                                                                                                                                                                            func (*Stmt) Status

                                                                                                                                                                                            func (s *Stmt) Status(op int, reset bool) int

                                                                                                                                                                                              Status returns the current value of a statement performance counter, specified by one of the STMTSTATUS constants. If reset is true, the value is reset back down to 0 after retrieval. [http://www.sqlite.org/c3ref/stmt_status.html]

                                                                                                                                                                                              func (*Stmt) String

                                                                                                                                                                                              func (s *Stmt) String() string

                                                                                                                                                                                                String returns the SQL text that was used to create this prepared statement. [http://www.sqlite.org/c3ref/sql.html]

                                                                                                                                                                                                func (*Stmt) Valid

                                                                                                                                                                                                func (s *Stmt) Valid() bool

                                                                                                                                                                                                  Valid returns true if the prepared statement can be executed by calling Exec or Query. A new prepared statement may not be valid if the SQL string contained nothing but comments or whitespace.

                                                                                                                                                                                                  type UpdateFunc

                                                                                                                                                                                                  type UpdateFunc func(op int, db, tbl RawString, row int64)

                                                                                                                                                                                                    UpdateFunc is a callback function invoked by SQLite when a row is updated, inserted, or deleted.

                                                                                                                                                                                                    type ZeroBlob

                                                                                                                                                                                                    type ZeroBlob int

                                                                                                                                                                                                      ZeroBlob is a special argument type used to allocate a zero-filled BLOB of the specified length. The BLOB can then be opened for incremental I/O to efficiently transfer a large amount of data. The maximum BLOB size can be queried with Conn.Limit(LIMIT_LENGTH, -1).

                                                                                                                                                                                                      Notes

                                                                                                                                                                                                      Bugs

                                                                                                                                                                                                        • The SQL statement "PRAGMA busy_timeout = n" does not clear the BusyFunc registered with the connection (if there is one). This causes the next call to Conn.BusyTimeout or Conn.BusyFunc to return a previous handler that wasn't actually being used. This doesn't affect the operation of SQLite in any way. Use Conn.BusyTimeout instead of the PRAGMA to avoid this problem if the return value is important.

                                                                                                                                                                                                          • If a SQLite memory allocation fails while scanning column values, the error is not reported until the next call to Stmt.Next or Stmt.Close. This behavior may change in the future to check for and return the error immediately from Stmt.Scan.

                                                                                                                                                                                                          Directories

                                                                                                                                                                                                          Path Synopsis
                                                                                                                                                                                                          Package codec provides authenticated encryption and other codecs for the sqlite3 package.
                                                                                                                                                                                                          Package codec provides authenticated encryption and other codecs for the sqlite3 package.