README

go-sqlite3

GoDoc Reference GitHub Actions Financial Contributors on Open Collective codecov Go Report Card

Latest stable version is v1.14 or later not v2.

NOTE: The increase to v2 was an accident. There were no major changes or features.

Description

sqlite3 driver conforming to the built-in database/sql interface

Supported Golang version: See .github/workflows/go.yaml

This package follows the official Golang Release Policy.

Overview

Installation

This package can be installed with the go get command:

go get github.com/mattn/go-sqlite3

go-sqlite3 is cgo package. If you want to build your app using go-sqlite3, you need gcc. However, after you have built and installed go-sqlite3 with go install github.com/mattn/go-sqlite3 (which requires gcc), you can build your app without relying on gcc in future.

Important: because this is a CGO enabled package you are required to set the environment variable CGO_ENABLED=1 and have a gcc compile present within your path.

API Reference

API documentation can be found here: http://godoc.org/github.com/mattn/go-sqlite3

Examples can be found under the examples directory

Connection String

When creating a new SQLite database or connection to an existing one, with the file name additional options can be given. This is also known as a DSN string. (Data Source Name).

Options are append after the filename of the SQLite database. The database filename and options are seperated by an ? (Question Mark). Options should be URL-encoded (see url.QueryEscape).

This also applies when using an in-memory database instead of a file.

Options can be given using the following format: KEYWORD=VALUE and multiple options can be combined with the & ampersand.

This library supports dsn options of SQLite itself and provides additional options.

Boolean values can be one of:

  • 0 no false off
  • 1 yes true on
Name Key Value(s) Description
UA - Create _auth - Create User Authentication, for more information see User Authentication
UA - Username _auth_user string Username for User Authentication, for more information see User Authentication
UA - Password _auth_pass string Password for User Authentication, for more information see User Authentication
UA - Crypt _auth_crypt
  • SHA1
  • SSHA1
  • SHA256
  • SSHA256
  • SHA384
  • SSHA384
  • SHA512
  • SSHA512
Password encoder to use for User Authentication, for more information see User Authentication
UA - Salt _auth_salt string Salt to use if the configure password encoder requires a salt, for User Authentication, for more information see User Authentication
Auto Vacuum _auto_vacuum | _vacuum
  • 0 | none
  • 1 | full
  • 2 | incremental
For more information see PRAGMA auto_vacuum
Busy Timeout _busy_timeout | _timeout int Specify value for sqlite3_busy_timeout. For more information see PRAGMA busy_timeout
Case Sensitive LIKE _case_sensitive_like | _cslike boolean For more information see PRAGMA case_sensitive_like
Defer Foreign Keys _defer_foreign_keys | _defer_fk boolean For more information see PRAGMA defer_foreign_keys
Foreign Keys _foreign_keys | _fk boolean For more information see PRAGMA foreign_keys
Ignore CHECK Constraints _ignore_check_constraints boolean For more information see PRAGMA ignore_check_constraints
Immutable immutable boolean For more information see Immutable
Journal Mode _journal_mode | _journal
  • DELETE
  • TRUNCATE
  • PERSIST
  • MEMORY
  • WAL
  • OFF
For more information see PRAGMA journal_mode
Locking Mode _locking_mode | _locking
  • NORMAL
  • EXCLUSIVE
For more information see PRAGMA locking_mode
Mode mode
  • ro
  • rw
  • rwc
  • memory
Access Mode of the database. For more information see SQLite Open
Mutex Locking _mutex
  • no
  • full
Specify mutex mode.
Query Only _query_only boolean For more information see PRAGMA query_only
Recursive Triggers _recursive_triggers | _rt boolean For more information see PRAGMA recursive_triggers
Secure Delete _secure_delete boolean | FAST For more information see PRAGMA secure_delete
Shared-Cache Mode cache
  • shared
  • private
Set cache mode for more information see sqlite.org
Synchronous _synchronous | _sync
  • 0 | OFF
  • 1 | NORMAL
  • 2 | FULL
  • 3 | EXTRA
For more information see PRAGMA synchronous
Time Zone Location _loc auto Specify location of time format.
Transaction Lock _txlock
  • immediate
  • deferred
  • exclusive
Specify locking behavior for transactions.
Writable Schema _writable_schema Boolean When this pragma is on, the SQLITE_MASTER tables in which database can be changed using ordinary UPDATE, INSERT, and DELETE statements. Warning: misuse of this pragma can easily result in a corrupt database file.
Cache Size _cache_size int Maximum cache size; default is 2000K (2M). See PRAGMA cache_size

DSN Examples

file:test.db?cache=shared&mode=memory

Features

This package allows additional configuration of features available within SQLite3 to be enabled or disabled by golang build constraints also known as build tags.

Click here for more information about build tags / constraints.

Usage

If you wish to build this library with additional extensions / features. Use the following command.

go build --tags "<FEATURE>"

For available features see the extension list. When using multiple build tags, all the different tags should be space delimted.

Example:

go build --tags "icu json1 fts5 secure_delete"
Feature / Extension List
Extension Build Tag Description
Additional Statistics sqlite_stat4 This option adds additional logic to the ANALYZE command and to the query planner that can help SQLite to chose a better query plan under certain situations. The ANALYZE command is enhanced to collect histogram data from all columns of every index and store that data in the sqlite_stat4 table.

The query planner will then use the histogram data to help it make better index choices. The downside of this compile-time option is that it violates the query planner stability guarantee making it more difficult to ensure consistent performance in mass-produced applications.

SQLITE_ENABLE_STAT4 is an enhancement of SQLITE_ENABLE_STAT3. STAT3 only recorded histogram data for the left-most column of each index whereas the STAT4 enhancement records histogram data from all columns of each index.

The SQLITE_ENABLE_STAT3 compile-time option is a no-op and is ignored if the SQLITE_ENABLE_STAT4 compile-time option is used
Allow URI Authority sqlite_allow_uri_authority URI filenames normally throws an error if the authority section is not either empty or "localhost".

However, if SQLite is compiled with the SQLITE_ALLOW_URI_AUTHORITY compile-time option, then the URI is converted into a Uniform Naming Convention (UNC) filename and passed down to the underlying operating system that way
App Armor sqlite_app_armor When defined, this C-preprocessor macro activates extra code that attempts to detect misuse of the SQLite API, such as passing in NULL pointers to required parameters or using objects after they have been destroyed.

App Armor is not available under Windows.
Disable Load Extensions sqlite_omit_load_extension Loading of external extensions is enabled by default.

To disable extension loading add the build tag sqlite_omit_load_extension.
Foreign Keys sqlite_foreign_keys This macro determines whether enforcement of foreign key constraints is enabled or disabled by default for new database connections.

Each database connection can always turn enforcement of foreign key constraints on and off and run-time using the foreign_keys pragma.

Enforcement of foreign key constraints is normally off by default, but if this compile-time parameter is set to 1, enforcement of foreign key constraints will be on by default
Full Auto Vacuum sqlite_vacuum_full Set the default auto vacuum to full
Incremental Auto Vacuum sqlite_vacuum_incr Set the default auto vacuum to incremental
Full Text Search Engine sqlite_fts5 When this option is defined in the amalgamation, versions 5 of the full-text search engine (fts5) is added to the build automatically
International Components for Unicode sqlite_icu This option causes the International Components for Unicode or "ICU" extension to SQLite to be added to the build
Introspect PRAGMAS sqlite_introspect This option adds some extra PRAGMA statements.
  • PRAGMA function_list
  • PRAGMA module_list
  • PRAGMA pragma_list
JSON SQL Functions sqlite_json When this option is defined in the amalgamation, the JSON SQL functions are added to the build automatically
Pre Update Hook sqlite_preupdate_hook Registers a callback function that is invoked prior to each INSERT, UPDATE, and DELETE operation on a database table.
Secure Delete sqlite_secure_delete This compile-time option changes the default setting of the secure_delete pragma.

When this option is not used, secure_delete defaults to off. When this option is present, secure_delete defaults to on.

The secure_delete setting causes deleted content to be overwritten with zeros. There is a small performance penalty since additional I/O must occur.

On the other hand, secure_delete can prevent fragments of sensitive information from lingering in unused parts of the database file after it has been deleted. See the documentation on the secure_delete pragma for additional information
Secure Delete (FAST) sqlite_secure_delete_fast For more information see PRAGMA secure_delete
Tracing / Debug sqlite_trace Activate trace functions
User Authentication sqlite_userauth SQLite User Authentication see User Authentication for more information.

Compilation

This package requires CGO_ENABLED=1 ennvironment variable if not set by default, and the presence of the gcc compiler.

If you need to add additional CFLAGS or LDFLAGS to the build command, and do not want to modify this package. Then this can be achieved by using the CGO_CFLAGS and CGO_LDFLAGS environment variables.

Android

This package can be compiled for android. Compile with:

go build --tags "android"

For more information see #201

ARM

To compile for ARM use the following environment.

env CC=arm-linux-gnueabihf-gcc CXX=arm-linux-gnueabihf-g++ \
    CGO_ENABLED=1 GOOS=linux GOARCH=arm GOARM=7 \
    go build -v 

Additional information:

Cross Compile

This library can be cross-compiled.

In some cases you are required to the CC environment variable with the cross compiler.

Cross Compiling from MAC OSX

The simplest way to cross compile from OSX is to use xgo.

Steps:

  • Install xgo (go get github.com/karalabe/xgo).
  • Ensure that your project is within your GOPATH.
  • Run xgo local/path/to/project.

Please refer to the project's README for further information.

Google Cloud Platform

Building on GCP is not possible because Google Cloud Platform does not allow gcc to be executed.

Please work only with compiled final binaries.

Linux

To compile this package on Linux you must install the development tools for your linux distribution.

To compile under linux use the build tag linux.

go build --tags "linux"

If you wish to link directly to libsqlite3 then you can use the libsqlite3 build tag.

go build --tags "libsqlite3 linux"
Alpine

When building in an alpine container run the following command before building.

apk add --update gcc musl-dev
Fedora
sudo yum groupinstall "Development Tools" "Development Libraries"
Ubuntu
sudo apt-get install build-essential

Mac OSX

OSX should have all the tools present to compile this package, if not install XCode this will add all the developers tools.

Required dependency

brew install sqlite3

For OSX there is an additional package install which is required if you wish to build the icu extension.

This additional package can be installed with homebrew.

brew upgrade icu4c

To compile for Mac OSX.

go build --tags "darwin"

If you wish to link directly to libsqlite3 then you can use the libsqlite3 build tag.

go build --tags "libsqlite3 darwin"

Additional information:

Windows

To compile this package on Windows OS you must have the gcc compiler installed.

  1. Install a Windows gcc toolchain.
  2. Add the bin folders to the Windows path if the installer did not do this by default.
  3. Open a terminal for the TDM-GCC toolchain, can be found in the Windows Start menu.
  4. Navigate to your project folder and run the go build ... command for this package.

For example the TDM-GCC Toolchain can be found here.

Errors

  • Compile error: can not be used when making a shared object; recompile with -fPIC

    When receiving a compile time error referencing recompile with -FPIC then you are probably using a hardend system.

    You can compile the library on a hardend system with the following command.

    go build -ldflags '-extldflags=-fno-PIC'
    

    More details see #120

  • Can't build go-sqlite3 on windows 64bit.

    Probably, you are using go 1.0, go1.0 has a problem when it comes to compiling/linking on windows 64bit. See: #27

  • go get github.com/mattn/go-sqlite3 throws compilation error.

    gcc throws: internal compiler error

    Remove the download repository from your disk and try re-install with:

    go install github.com/mattn/go-sqlite3
    

User Authentication

This package supports the SQLite User Authentication module.

Compile

To use the User authentication module the package has to be compiled with the tag sqlite_userauth. See Features.

Usage

Create protected database

To create a database protected by user authentication provide the following argument to the connection string _auth. This will enable user authentication within the database. This option however requires two additional arguments:

  • _auth_user
  • _auth_pass

When _auth is present on the connection string user authentication will be enabled and the provided user will be created as an admin user. After initial creation, the parameter _auth has no effect anymore and can be omitted from the connection string.

Example connection string:

Create an user authentication database with user admin and password admin.

file:test.s3db?_auth&_auth_user=admin&_auth_pass=admin

Create an user authentication database with user admin and password admin and use SHA1 for the password encoding.

file:test.s3db?_auth&_auth_user=admin&_auth_pass=admin&_auth_crypt=sha1

Password Encoding

The passwords within the user authentication module of SQLite are encoded with the SQLite function sqlite_cryp. This function uses a ceasar-cypher which is quite insecure. This library provides several additional password encoders which can be configured through the connection string.

The password cypher can be configured with the key _auth_crypt. And if the configured password encoder also requires an salt this can be configured with _auth_salt.

Available Encoders
  • SHA1
  • SSHA1 (Salted SHA1)
  • SHA256
  • SSHA256 (salted SHA256)
  • SHA384
  • SSHA384 (salted SHA384)
  • SHA512
  • SSHA512 (salted SHA512)
Restrictions

Operations on the database regarding to user management can only be preformed by an administrator user.

Support

The user authentication supports two kinds of users

  • administrators
  • regular users
User Management

User management can be done by directly using the *SQLiteConn or by SQL.

SQL

The following sql functions are available for user management.

Function Arguments Description
authenticate username string, password string Will authenticate an user, this is done by the connection; and should not be used manually.
auth_user_add username string, password string, admin int This function will add an user to the database.
if the database is not protected by user authentication it will enable it. Argument admin is an integer identifying if the added user should be an administrator. Only Administrators can add administrators.
auth_user_change username string, password string, admin int Function to modify an user. Users can change their own password, but only an administrator can change the administrator flag.
authUserDelete username string Delete an user from the database. Can only be used by an administrator. The current logged in administrator cannot be deleted. This is to make sure their is always an administrator remaining.

These functions will return an integer.

  • 0 (SQLITE_OK)
  • 23 (SQLITE_AUTH) Failed to perform due to authentication or insufficient privileges
Examples
// Autheticate user
// Create Admin User
SELECT auth_user_add('admin2', 'admin2', 1);

// Change password for user
SELECT auth_user_change('user', 'userpassword', 0);

// Delete user
SELECT user_delete('user');
*SQLiteConn

The following functions are available for User authentication from the *SQLiteConn.

Function Description
Authenticate(username, password string) error Authenticate user
AuthUserAdd(username, password string, admin bool) error Add user
AuthUserChange(username, password string, admin bool) error Modify user
AuthUserDelete(username string) error Delete user
Attached database

When using attached databases. SQLite will use the authentication from the main database for the attached database(s).

Extensions

If you want your own extension to be listed here or you want to add a reference to an extension; please submit an Issue for this.

Spatialite

Spatialite is available as an extension to SQLite, and can be used in combination with this repository. For an example see shaxbee/go-spatialite.

extension-functions.c from SQLite3 Contrib

extension-functions.c is available as an extension to SQLite, and provides the following functions:

  • Math: acos, asin, atan, atn2, atan2, acosh, asinh, atanh, difference, degrees, radians, cos, sin, tan, cot, cosh, sinh, tanh, coth, exp, log, log10, power, sign, sqrt, square, ceil, floor, pi.
  • String: replicate, charindex, leftstr, rightstr, ltrim, rtrim, trim, replace, reverse, proper, padl, padr, padc, strfilter.
  • Aggregate: stdev, variance, mode, median, lower_quartile, upper_quartile

For an example see dinedal/go-sqlite3-extension-functions.

FAQ

  • Getting insert error while query is opened.

    You can pass some arguments into the connection string, for example, a URI. See: #39

  • Do you want to cross compile? mingw on Linux or Mac?

    See: #106 See also: http://www.limitlessfx.com/cross-compile-golang-app-for-windows-from-linux.html

  • Want to get time.Time with current locale

    Use _loc=auto in SQLite3 filename schema like file:foo.db?_loc=auto.

  • Can I use this in multiple routines concurrently?

    Yes for readonly. But, No for writable. See #50, #51, #209, #274.

  • Why I'm getting no such table error?

    Why is it racy if I use a sql.Open("sqlite3", ":memory:") database?

    Each connection to ":memory:" opens a brand new in-memory sql database, so if the stdlib's sql engine happens to open another connection and you've only specified ":memory:", that connection will see a brand new database. A workaround is to use "file::memory:?cache=shared" (or "file:foobar?mode=memory&cache=shared"). Every connection to this string will point to the same in-memory database.

    Note that if the last database connection in the pool closes, the in-memory database is deleted. Make sure the max idle connection limit is > 0, and the connection lifetime is infinite.

    For more information see

  • Reading from database with large amount of goroutines fails on OSX.

    OS X limits OS-wide to not have more than 1000 files open simultaneously by default.

    For more information see #289

  • Trying to execute a . (dot) command throws an error.

    Error: Error: near ".": syntax error Dot command are part of SQLite3 CLI not of this library.

    You need to implement the feature or call the sqlite3 cli.

    More information see #305

  • Error: database is locked

    When you get a database is locked. Please use the following options.

    Add to DSN: cache=shared

    Example:

    db, err := sql.Open("sqlite3", "file:locked.sqlite?cache=shared")
    

    Second please set the database connections of the SQL package to 1.

    db.SetMaxOpenConns(1)
    

    More information see #209

Contributors

Code Contributors

This project exists thanks to all the people who contribute. [Contribute].

Financial Contributors

Become a financial contributor and help us sustain our community. [Contribute]

Individuals

Organizations

Support this project with your organization. Your logo will show up here with a link to your website. [Contribute]

License

MIT: http://mattn.mit-license.org/2018

sqlite3-binding.c, sqlite3-binding.h, sqlite3ext.h

The -binding suffix was added to avoid build failures under gccgo.

In this repository, those files are an amalgamation of code that was copied from SQLite3. The license of that code is the same as the license of SQLite3.

Author

Yasuhiro Matsumoto (a.k.a mattn)

G.J.R. Timmer

Expand ▾ Collapse ▴

Documentation

Overview

Package sqlite3 provides interface to SQLite3 databases.

This works as a driver for database/sql.

Installation

go get github.com/mattn/go-sqlite3

Supported Types

Currently, go-sqlite3 supports the following data types.

+------------------------------+
|go        | sqlite3           |
|----------|-------------------|
|nil       | null              |
|int       | integer           |
|int64     | integer           |
|float64   | float             |
|bool      | integer           |
|[]byte    | blob              |
|string    | text              |
|time.Time | timestamp/datetime|
+------------------------------+

SQLite3 Extension

You can write your own extension module for sqlite3. For example, below is an extension for a Regexp matcher operation.

#include <pcre.h>
#include <string.h>
#include <stdio.h>
#include <sqlite3ext.h>

SQLITE_EXTENSION_INIT1
static void regexp_func(sqlite3_context *context, int argc, sqlite3_value **argv) {
  if (argc >= 2) {
    const char *target  = (const char *)sqlite3_value_text(argv[1]);
    const char *pattern = (const char *)sqlite3_value_text(argv[0]);
    const char* errstr = NULL;
    int erroff = 0;
    int vec[500];
    int n, rc;
    pcre* re = pcre_compile(pattern, 0, &errstr, &erroff, NULL);
    rc = pcre_exec(re, NULL, target, strlen(target), 0, 0, vec, 500);
    if (rc <= 0) {
      sqlite3_result_error(context, errstr, 0);
      return;
    }
    sqlite3_result_int(context, 1);
  }
}

#ifdef _WIN32
__declspec(dllexport)
#endif
int sqlite3_extension_init(sqlite3 *db, char **errmsg,
      const sqlite3_api_routines *api) {
  SQLITE_EXTENSION_INIT2(api);
  return sqlite3_create_function(db, "regexp", 2, SQLITE_UTF8,
      (void*)db, regexp_func, NULL, NULL);
}

It needs to be built as a so/dll shared library. And you need to register the extension module like below.

sql.Register("sqlite3_with_extensions",
	&sqlite3.SQLiteDriver{
		Extensions: []string{
			"sqlite3_mod_regexp",
		},
	})

Then, you can use this extension.

rows, err := db.Query("select text from mytable where name regexp '^golang'")

Connection Hook

You can hook and inject your code when the connection is established by setting ConnectHook to get the SQLiteConn.

sql.Register("sqlite3_with_hook_example",
		&sqlite3.SQLiteDriver{
				ConnectHook: func(conn *sqlite3.SQLiteConn) error {
					sqlite3conn = append(sqlite3conn, conn)
					return nil
				},
		})

You can also use database/sql.Conn.Raw (Go >= 1.13):

conn, err := db.Conn(context.Background())
// if err != nil { ... }
defer conn.Close()
err = conn.Raw(func (driverConn interface{}) error {
	sqliteConn := driverConn.(*sqlite3.SQLiteConn)
	// ... use sqliteConn
})
// if err != nil { ... }

Go SQlite3 Extensions

If you want to register Go functions as SQLite extension functions you can make a custom driver by calling RegisterFunction from ConnectHook.

regex = func(re, s string) (bool, error) {
	return regexp.MatchString(re, s)
}
sql.Register("sqlite3_extended",
		&sqlite3.SQLiteDriver{
				ConnectHook: func(conn *sqlite3.SQLiteConn) error {
					return conn.RegisterFunc("regexp", regex, true)
				},
		})

You can then use the custom driver by passing its name to sql.Open.

var i int
conn, err := sql.Open("sqlite3_extended", "./foo.db")
if err != nil {
	panic(err)
}
err = db.QueryRow(`SELECT regexp("foo.*", "seafood")`).Scan(&i)
if err != nil {
	panic(err)
}

See the documentation of RegisterFunc for more details.

Index

Constants

View Source
const (
	// used by authorizer and pre_update_hook
	SQLITE_DELETE = C.SQLITE_DELETE
	SQLITE_INSERT = C.SQLITE_INSERT
	SQLITE_UPDATE = C.SQLITE_UPDATE

	// used by authorzier - as return value
	SQLITE_OK     = C.SQLITE_OK
	SQLITE_IGNORE = C.SQLITE_IGNORE
	SQLITE_DENY   = C.SQLITE_DENY

	// different actions query tries to do - passed as argument to authorizer
	SQLITE_CREATE_INDEX        = C.SQLITE_CREATE_INDEX
	SQLITE_CREATE_TABLE        = C.SQLITE_CREATE_TABLE
	SQLITE_CREATE_TEMP_INDEX   = C.SQLITE_CREATE_TEMP_INDEX
	SQLITE_CREATE_TEMP_TABLE   = C.SQLITE_CREATE_TEMP_TABLE
	SQLITE_CREATE_TEMP_TRIGGER = C.SQLITE_CREATE_TEMP_TRIGGER
	SQLITE_CREATE_TEMP_VIEW    = C.SQLITE_CREATE_TEMP_VIEW
	SQLITE_CREATE_TRIGGER      = C.SQLITE_CREATE_TRIGGER
	SQLITE_CREATE_VIEW         = C.SQLITE_CREATE_VIEW
	SQLITE_CREATE_VTABLE       = C.SQLITE_CREATE_VTABLE
	SQLITE_DROP_INDEX          = C.SQLITE_DROP_INDEX
	SQLITE_DROP_TABLE          = C.SQLITE_DROP_TABLE
	SQLITE_DROP_TEMP_INDEX     = C.SQLITE_DROP_TEMP_INDEX
	SQLITE_DROP_TEMP_TABLE     = C.SQLITE_DROP_TEMP_TABLE
	SQLITE_DROP_TEMP_TRIGGER   = C.SQLITE_DROP_TEMP_TRIGGER
	SQLITE_DROP_TEMP_VIEW      = C.SQLITE_DROP_TEMP_VIEW
	SQLITE_DROP_TRIGGER        = C.SQLITE_DROP_TRIGGER
	SQLITE_DROP_VIEW           = C.SQLITE_DROP_VIEW
	SQLITE_DROP_VTABLE         = C.SQLITE_DROP_VTABLE
	SQLITE_PRAGMA              = C.SQLITE_PRAGMA
	SQLITE_READ                = C.SQLITE_READ
	SQLITE_SELECT              = C.SQLITE_SELECT
	SQLITE_TRANSACTION         = C.SQLITE_TRANSACTION
	SQLITE_ATTACH              = C.SQLITE_ATTACH
	SQLITE_DETACH              = C.SQLITE_DETACH
	SQLITE_ALTER_TABLE         = C.SQLITE_ALTER_TABLE
	SQLITE_REINDEX             = C.SQLITE_REINDEX
	SQLITE_ANALYZE             = C.SQLITE_ANALYZE
	SQLITE_FUNCTION            = C.SQLITE_FUNCTION
	SQLITE_SAVEPOINT           = C.SQLITE_SAVEPOINT
	SQLITE_COPY                = C.SQLITE_COPY
)
View Source
const (
	SQLITE_LIMIT_LENGTH              = C.SQLITE_LIMIT_LENGTH
	SQLITE_LIMIT_SQL_LENGTH          = C.SQLITE_LIMIT_SQL_LENGTH
	SQLITE_LIMIT_COLUMN              = C.SQLITE_LIMIT_COLUMN
	SQLITE_LIMIT_EXPR_DEPTH          = C.SQLITE_LIMIT_EXPR_DEPTH
	SQLITE_LIMIT_COMPOUND_SELECT     = C.SQLITE_LIMIT_COMPOUND_SELECT
	SQLITE_LIMIT_VDBE_OP             = C.SQLITE_LIMIT_VDBE_OP
	SQLITE_LIMIT_FUNCTION_ARG        = C.SQLITE_LIMIT_FUNCTION_ARG
	SQLITE_LIMIT_ATTACHED            = C.SQLITE_LIMIT_ATTACHED
	SQLITE_LIMIT_LIKE_PATTERN_LENGTH = C.SQLITE_LIMIT_LIKE_PATTERN_LENGTH
	SQLITE_LIMIT_VARIABLE_NUMBER     = C.SQLITE_LIMIT_VARIABLE_NUMBER
	SQLITE_LIMIT_TRIGGER_DEPTH       = C.SQLITE_LIMIT_TRIGGER_DEPTH
	SQLITE_LIMIT_WORKER_THREADS      = C.SQLITE_LIMIT_WORKER_THREADS
)

    Run-Time Limit Categories. See: http://www.sqlite.org/c3ref/c_limit_attached.html

    View Source
    const ErrNoMask C.int = 0xff

      ErrNoMask is mask code.

      Variables

      View Source
      var (
      	ErrError      = ErrNo(1)  /* SQL error or missing database */
      	ErrInternal   = ErrNo(2)  /* Internal logic error in SQLite */
      	ErrPerm       = ErrNo(3)  /* Access permission denied */
      	ErrAbort      = ErrNo(4)  /* Callback routine requested an abort */
      	ErrBusy       = ErrNo(5)  /* The database file is locked */
      	ErrLocked     = ErrNo(6)  /* A table in the database is locked */
      	ErrNomem      = ErrNo(7)  /* A malloc() failed */
      	ErrReadonly   = ErrNo(8)  /* Attempt to write a readonly database */
      	ErrInterrupt  = ErrNo(9)  /* Operation terminated by sqlite3_interrupt() */
      	ErrIoErr      = ErrNo(10) /* Some kind of disk I/O error occurred */
      	ErrCorrupt    = ErrNo(11) /* The database disk image is malformed */
      	ErrNotFound   = ErrNo(12) /* Unknown opcode in sqlite3_file_control() */
      	ErrFull       = ErrNo(13) /* Insertion failed because database is full */
      	ErrCantOpen   = ErrNo(14) /* Unable to open the database file */
      	ErrProtocol   = ErrNo(15) /* Database lock protocol error */
      	ErrEmpty      = ErrNo(16) /* Database is empty */
      	ErrSchema     = ErrNo(17) /* The database schema changed */
      	ErrTooBig     = ErrNo(18) /* String or BLOB exceeds size limit */
      	ErrConstraint = ErrNo(19) /* Abort due to constraint violation */
      	ErrMismatch   = ErrNo(20) /* Data type mismatch */
      	ErrMisuse     = ErrNo(21) /* Library used incorrectly */
      	ErrNoLFS      = ErrNo(22) /* Uses OS features not supported on host */
      	ErrAuth       = ErrNo(23) /* Authorization denied */
      	ErrFormat     = ErrNo(24) /* Auxiliary database format error */
      	ErrRange      = ErrNo(25) /* 2nd parameter to sqlite3_bind out of range */
      	ErrNotADB     = ErrNo(26) /* File opened that is not a database file */
      	ErrNotice     = ErrNo(27) /* Notifications from sqlite3_log() */
      	ErrWarning    = ErrNo(28) /* Warnings from sqlite3_log() */
      )

        result codes from http://www.sqlite.org/c3ref/c_abort.html

        View Source
        var (
        	ErrIoErrRead              = ErrIoErr.Extend(1)
        	ErrIoErrShortRead         = ErrIoErr.Extend(2)
        	ErrIoErrWrite             = ErrIoErr.Extend(3)
        	ErrIoErrFsync             = ErrIoErr.Extend(4)
        	ErrIoErrDirFsync          = ErrIoErr.Extend(5)
        	ErrIoErrTruncate          = ErrIoErr.Extend(6)
        	ErrIoErrFstat             = ErrIoErr.Extend(7)
        	ErrIoErrUnlock            = ErrIoErr.Extend(8)
        	ErrIoErrRDlock            = ErrIoErr.Extend(9)
        	ErrIoErrDelete            = ErrIoErr.Extend(10)
        	ErrIoErrBlocked           = ErrIoErr.Extend(11)
        	ErrIoErrNoMem             = ErrIoErr.Extend(12)
        	ErrIoErrAccess            = ErrIoErr.Extend(13)
        	ErrIoErrCheckReservedLock = ErrIoErr.Extend(14)
        	ErrIoErrLock              = ErrIoErr.Extend(15)
        	ErrIoErrClose             = ErrIoErr.Extend(16)
        	ErrIoErrDirClose          = ErrIoErr.Extend(17)
        	ErrIoErrSHMOpen           = ErrIoErr.Extend(18)
        	ErrIoErrSHMSize           = ErrIoErr.Extend(19)
        	ErrIoErrSHMLock           = ErrIoErr.Extend(20)
        	ErrIoErrSHMMap            = ErrIoErr.Extend(21)
        	ErrIoErrSeek              = ErrIoErr.Extend(22)
        	ErrIoErrDeleteNoent       = ErrIoErr.Extend(23)
        	ErrIoErrMMap              = ErrIoErr.Extend(24)
        	ErrIoErrGetTempPath       = ErrIoErr.Extend(25)
        	ErrIoErrConvPath          = ErrIoErr.Extend(26)
        	ErrLockedSharedCache      = ErrLocked.Extend(1)
        	ErrBusyRecovery           = ErrBusy.Extend(1)
        	ErrBusySnapshot           = ErrBusy.Extend(2)
        	ErrCantOpenNoTempDir      = ErrCantOpen.Extend(1)
        	ErrCantOpenIsDir          = ErrCantOpen.Extend(2)
        	ErrCantOpenFullPath       = ErrCantOpen.Extend(3)
        	ErrCantOpenConvPath       = ErrCantOpen.Extend(4)
        	ErrCorruptVTab            = ErrCorrupt.Extend(1)
        	ErrReadonlyRecovery       = ErrReadonly.Extend(1)
        	ErrReadonlyCantLock       = ErrReadonly.Extend(2)
        	ErrReadonlyRollback       = ErrReadonly.Extend(3)
        	ErrReadonlyDbMoved        = ErrReadonly.Extend(4)
        	ErrAbortRollback          = ErrAbort.Extend(2)
        	ErrConstraintCheck        = ErrConstraint.Extend(1)
        	ErrConstraintCommitHook   = ErrConstraint.Extend(2)
        	ErrConstraintForeignKey   = ErrConstraint.Extend(3)
        	ErrConstraintFunction     = ErrConstraint.Extend(4)
        	ErrConstraintNotNull      = ErrConstraint.Extend(5)
        	ErrConstraintPrimaryKey   = ErrConstraint.Extend(6)
        	ErrConstraintTrigger      = ErrConstraint.Extend(7)
        	ErrConstraintUnique       = ErrConstraint.Extend(8)
        	ErrConstraintVTab         = ErrConstraint.Extend(9)
        	ErrConstraintRowID        = ErrConstraint.Extend(10)
        	ErrNoticeRecoverWAL       = ErrNotice.Extend(1)
        	ErrNoticeRecoverRollback  = ErrNotice.Extend(2)
        	ErrWarningAutoIndex       = ErrWarning.Extend(1)
        )

          result codes from http://www.sqlite.org/c3ref/c_abort_rollback.html

          View Source
          var SQLiteTimestampFormats = []string{
          
          	"2006-01-02 15:04:05.999999999-07:00",
          	"2006-01-02T15:04:05.999999999-07:00",
          	"2006-01-02 15:04:05.999999999",
          	"2006-01-02T15:04:05.999999999",
          	"2006-01-02 15:04:05",
          	"2006-01-02T15:04:05",
          	"2006-01-02 15:04",
          	"2006-01-02T15:04",
          	"2006-01-02",
          }

            SQLiteTimestampFormats is timestamp formats understood by both this module and SQLite. The first format in the slice will be used when saving time values into the database. When parsing a string from a timestamp or datetime column, the formats are tried in order.

            Functions

            func CryptEncoderSHA1

            func CryptEncoderSHA1(pass []byte, hash interface{}) []byte

              CryptEncoderSHA1 encodes a password with SHA1

              func CryptEncoderSHA256

              func CryptEncoderSHA256(pass []byte, hash interface{}) []byte

                CryptEncoderSHA256 encodes a password with SHA256

                func CryptEncoderSHA384

                func CryptEncoderSHA384(pass []byte, hash interface{}) []byte

                  CryptEncoderSHA384 encodes a password with SHA384

                  func CryptEncoderSHA512

                  func CryptEncoderSHA512(pass []byte, hash interface{}) []byte

                    CryptEncoderSHA512 encodes a password with SHA512

                    func CryptEncoderSSHA1

                    func CryptEncoderSSHA1(salt string) func(pass []byte, hash interface{}) []byte

                      CryptEncoderSSHA1 encodes a password with SHA1 with the configured salt.

                      func CryptEncoderSSHA256

                      func CryptEncoderSSHA256(salt string) func(pass []byte, hash interface{}) []byte

                        CryptEncoderSSHA256 encodes a password with SHA256 with the configured salt

                        func CryptEncoderSSHA384

                        func CryptEncoderSSHA384(salt string) func(pass []byte, hash interface{}) []byte

                          CryptEncoderSSHA384 encodes a password with SHA384 with the configured salt

                          func CryptEncoderSSHA512

                          func CryptEncoderSSHA512(salt string) func(pass []byte, hash interface{}) []byte

                            CryptEncoderSSHA512 encodes a password with SHA512 with the configured salt

                            func Version

                            func Version() (libVersion string, libVersionNumber int, sourceID string)

                              Version returns SQLite library version information.

                              Types

                              type ErrNo

                              type ErrNo int

                                ErrNo inherit errno.

                                func (ErrNo) Error

                                func (err ErrNo) Error() string

                                  Error return error message from errno.

                                  func (ErrNo) Extend

                                  func (err ErrNo) Extend(by int) ErrNoExtended

                                    Extend return extended errno.

                                    type ErrNoExtended

                                    type ErrNoExtended int

                                      ErrNoExtended is extended errno.

                                      func (ErrNoExtended) Error

                                      func (err ErrNoExtended) Error() string

                                        Error return error message that is extended code.

                                        type Error

                                        type Error struct {
                                        	Code         ErrNo         /* The error code returned by SQLite */
                                        	ExtendedCode ErrNoExtended /* The extended error code returned by SQLite */
                                        	SystemErrno  syscall.Errno /* The system errno returned by the OS through SQLite, if applicable */
                                        	// contains filtered or unexported fields
                                        }

                                          Error implement sqlite error code.

                                          func (Error) Error

                                          func (err Error) Error() string

                                          type SQLiteBackup

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

                                            SQLiteBackup implement interface of Backup.

                                            func (*SQLiteBackup) Close

                                            func (b *SQLiteBackup) Close() error

                                              Close close backup.

                                              func (*SQLiteBackup) Finish

                                              func (b *SQLiteBackup) Finish() error

                                                Finish close backup.

                                                func (*SQLiteBackup) PageCount

                                                func (b *SQLiteBackup) PageCount() int

                                                  PageCount return count of pages.

                                                  func (*SQLiteBackup) Remaining

                                                  func (b *SQLiteBackup) Remaining() int

                                                    Remaining return whether have the rest for backup.

                                                    func (*SQLiteBackup) Step

                                                    func (b *SQLiteBackup) Step(p int) (bool, error)

                                                      Step to backs up for one step. Calls the underlying `sqlite3_backup_step` function. This function returns a boolean indicating if the backup is done and an error signalling any other error. Done is returned if the underlying C function returns SQLITE_DONE (Code 101)

                                                      type SQLiteConn

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

                                                        SQLiteConn implements driver.Conn.

                                                        func (*SQLiteConn) AuthEnabled

                                                        func (c *SQLiteConn) AuthEnabled() (exists bool)

                                                          AuthEnabled checks if the database is protected by user authentication

                                                          func (*SQLiteConn) AuthUserAdd

                                                          func (c *SQLiteConn) AuthUserAdd(username, password string, admin bool) error

                                                            AuthUserAdd can be used (by an admin user only) to create a new user. When called on a no-authentication-required database, this routine converts the database into an authentication- required database, automatically makes the added user an administrator, and logs in the current connection as that user. The AuthUserAdd only works for the "main" database, not for any ATTACH-ed databases. Any call to AuthUserAdd by a non-admin user results in an error.

                                                            func (*SQLiteConn) AuthUserChange

                                                            func (c *SQLiteConn) AuthUserChange(username, password string, admin bool) error

                                                              AuthUserChange can be used to change a users login credentials or admin privilege. Any user can change their own login credentials. Only an admin user can change another users login credentials or admin privilege setting. No user may change their own admin privilege setting.

                                                              func (*SQLiteConn) AuthUserDelete

                                                              func (c *SQLiteConn) AuthUserDelete(username string) error

                                                                AuthUserDelete can be used (by an admin user only) to delete a user. The currently logged-in user cannot be deleted, which guarantees that there is always an admin user and hence that the database cannot be converted into a no-authentication-required database.

                                                                func (*SQLiteConn) Authenticate

                                                                func (c *SQLiteConn) Authenticate(username, password string) error

                                                                  Authenticate will perform an authentication of the provided username and password against the database.

                                                                  If a database contains the SQLITE_USER table, then the call to Authenticate must be invoked with an appropriate username and password prior to enable read and write access to the database.

                                                                  Return SQLITE_OK on success or SQLITE_ERROR if the username/password combination is incorrect or unknown.

                                                                  If the SQLITE_USER table is not present in the database file, then this interface is a harmless no-op returnning SQLITE_OK.

                                                                  func (*SQLiteConn) AutoCommit

                                                                  func (c *SQLiteConn) AutoCommit() bool

                                                                    AutoCommit return which currently auto commit or not.

                                                                    func (*SQLiteConn) Backup

                                                                    func (destConn *SQLiteConn) Backup(dest string, srcConn *SQLiteConn, src string) (*SQLiteBackup, error)

                                                                      Backup make backup from src to dest.

                                                                      func (*SQLiteConn) Begin

                                                                      func (c *SQLiteConn) Begin() (driver.Tx, error)

                                                                        Begin transaction.

                                                                        func (*SQLiteConn) BeginTx

                                                                        func (c *SQLiteConn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error)

                                                                          BeginTx implement ConnBeginTx.

                                                                          func (*SQLiteConn) Close

                                                                          func (c *SQLiteConn) Close() error

                                                                            Close the connection.

                                                                            func (*SQLiteConn) Exec

                                                                            func (c *SQLiteConn) Exec(query string, args []driver.Value) (driver.Result, error)

                                                                              Exec implements Execer.

                                                                              func (*SQLiteConn) ExecContext

                                                                              func (c *SQLiteConn) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error)

                                                                                ExecContext implement ExecerContext.

                                                                                func (*SQLiteConn) GetFilename

                                                                                func (c *SQLiteConn) GetFilename(schemaName string) string

                                                                                  GetFilename returns the absolute path to the file containing the requested schema. When passed an empty string, it will instead use the database's default schema: "main". See: sqlite3_db_filename, https://www.sqlite.org/c3ref/db_filename.html

                                                                                  func (*SQLiteConn) GetLimit

                                                                                  func (c *SQLiteConn) GetLimit(id int) int

                                                                                    GetLimit returns the current value of a run-time limit. See: sqlite3_limit, http://www.sqlite.org/c3ref/limit.html

                                                                                    func (*SQLiteConn) LoadExtension

                                                                                    func (c *SQLiteConn) LoadExtension(lib string, entry string) error

                                                                                      LoadExtension load the sqlite3 extension.

                                                                                      func (*SQLiteConn) Ping

                                                                                      func (c *SQLiteConn) Ping(ctx context.Context) error

                                                                                        Ping implement Pinger.

                                                                                        func (*SQLiteConn) Prepare

                                                                                        func (c *SQLiteConn) Prepare(query string) (driver.Stmt, error)

                                                                                          Prepare the query string. Return a new statement.

                                                                                          func (*SQLiteConn) PrepareContext

                                                                                          func (c *SQLiteConn) PrepareContext(ctx context.Context, query string) (driver.Stmt, error)

                                                                                            PrepareContext implement ConnPrepareContext.

                                                                                            func (*SQLiteConn) Query

                                                                                            func (c *SQLiteConn) Query(query string, args []driver.Value) (driver.Rows, error)

                                                                                              Query implements Queryer.

                                                                                              func (*SQLiteConn) QueryContext

                                                                                              func (c *SQLiteConn) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error)

                                                                                                QueryContext implement QueryerContext.

                                                                                                func (*SQLiteConn) RegisterAggregator

                                                                                                func (c *SQLiteConn) RegisterAggregator(name string, impl interface{}, pure bool) error

                                                                                                  RegisterAggregator makes a Go type available as a SQLite aggregation function.

                                                                                                  Because aggregation is incremental, it's implemented in Go with a type that has 2 methods: func Step(values) accumulates one row of data into the accumulator, and func Done() ret finalizes and returns the aggregate value. "values" and "ret" may be any type supported by RegisterFunc.

                                                                                                  RegisterAggregator takes as implementation a constructor function that constructs an instance of the aggregator type each time an aggregation begins. The constructor must return a pointer to a type, or an interface that implements Step() and Done().

                                                                                                  The constructor function and the Step/Done methods may optionally return an error in addition to their other return values.

                                                                                                  See _example/go_custom_funcs for a detailed example.

                                                                                                  func (*SQLiteConn) RegisterAuthorizer

                                                                                                  func (c *SQLiteConn) RegisterAuthorizer(callback func(int, string, string, string) int)

                                                                                                    RegisterAuthorizer sets the authorizer for connection.

                                                                                                    The parameters to the callback are the operation (one of the constants SQLITE_INSERT, SQLITE_DELETE, or SQLITE_UPDATE), and 1 to 3 arguments, depending on operation. More details see: https://www.sqlite.org/c3ref/c_alter_table.html

                                                                                                    func (*SQLiteConn) RegisterCollation

                                                                                                    func (c *SQLiteConn) RegisterCollation(name string, cmp func(string, string) int) error

                                                                                                      RegisterCollation makes a Go function available as a collation.

                                                                                                      cmp receives two UTF-8 strings, a and b. The result should be 0 if a==b, -1 if a < b, and +1 if a > b.

                                                                                                      cmp must always return the same result given the same inputs. Additionally, it must have the following properties for all strings A, B and C: if A==B then B==A; if A==B and B==C then A==C; if A<B then B>A; if A<B and B<C then A<C.

                                                                                                      If cmp does not obey these constraints, sqlite3's behavior is undefined when the collation is used.

                                                                                                      func (*SQLiteConn) RegisterCommitHook

                                                                                                      func (c *SQLiteConn) RegisterCommitHook(callback func() int)

                                                                                                        RegisterCommitHook sets the commit hook for a connection.

                                                                                                        If the callback returns non-zero the transaction will become a rollback.

                                                                                                        If there is an existing commit hook for this connection, it will be removed. If callback is nil the existing hook (if any) will be removed without creating a new one.

                                                                                                        func (*SQLiteConn) RegisterFunc

                                                                                                        func (c *SQLiteConn) RegisterFunc(name string, impl interface{}, pure bool) error

                                                                                                          RegisterFunc makes a Go function available as a SQLite function.

                                                                                                          The Go function can have arguments of the following types: any numeric type except complex, bool, []byte, string and interface{}. interface{} arguments are given the direct translation of the SQLite data type: int64 for INTEGER, float64 for FLOAT, []byte for BLOB, string for TEXT.

                                                                                                          The function can additionally be variadic, as long as the type of the variadic argument is one of the above.

                                                                                                          If pure is true. SQLite will assume that the function's return value depends only on its inputs, and make more aggressive optimizations in its queries.

                                                                                                          See _example/go_custom_funcs for a detailed example.

                                                                                                          func (*SQLiteConn) RegisterPreUpdateHook

                                                                                                          func (c *SQLiteConn) RegisterPreUpdateHook(callback func(SQLitePreUpdateData))

                                                                                                            RegisterPreUpdateHook sets the pre-update hook for a connection.

                                                                                                            The callback is passed a SQLitePreUpdateData struct with the data for the update, as well as methods for fetching copies of impacted data.

                                                                                                            If there is an existing update hook for this connection, it will be removed. If callback is nil the existing hook (if any) will be removed without creating a new one.

                                                                                                            func (*SQLiteConn) RegisterRollbackHook

                                                                                                            func (c *SQLiteConn) RegisterRollbackHook(callback func())

                                                                                                              RegisterRollbackHook sets the rollback hook for a connection.

                                                                                                              If there is an existing rollback hook for this connection, it will be removed. If callback is nil the existing hook (if any) will be removed without creating a new one.

                                                                                                              func (*SQLiteConn) RegisterUpdateHook

                                                                                                              func (c *SQLiteConn) RegisterUpdateHook(callback func(int, string, string, int64))

                                                                                                                RegisterUpdateHook sets the update hook for a connection.

                                                                                                                The parameters to the callback are the operation (one of the constants SQLITE_INSERT, SQLITE_DELETE, or SQLITE_UPDATE), the database name, the table name, and the rowid.

                                                                                                                If there is an existing update hook for this connection, it will be removed. If callback is nil the existing hook (if any) will be removed without creating a new one.

                                                                                                                func (*SQLiteConn) SetLimit

                                                                                                                func (c *SQLiteConn) SetLimit(id int, newVal int) int

                                                                                                                  SetLimit changes the value of a run-time limits. Then this method returns the prior value of the limit. See: sqlite3_limit, http://www.sqlite.org/c3ref/limit.html

                                                                                                                  type SQLiteContext

                                                                                                                  type SQLiteContext C.sqlite3_context

                                                                                                                    SQLiteContext behave sqlite3_context

                                                                                                                    func (*SQLiteContext) ResultBlob

                                                                                                                    func (c *SQLiteContext) ResultBlob(b []byte)

                                                                                                                      ResultBlob sets the result of an SQL function. See: sqlite3_result_blob, http://sqlite.org/c3ref/result_blob.html

                                                                                                                      func (*SQLiteContext) ResultBool

                                                                                                                      func (c *SQLiteContext) ResultBool(b bool)

                                                                                                                        ResultBool sets the result of an SQL function.

                                                                                                                        func (*SQLiteContext) ResultDouble

                                                                                                                        func (c *SQLiteContext) ResultDouble(d float64)

                                                                                                                          ResultDouble sets the result of an SQL function. See: sqlite3_result_double, http://sqlite.org/c3ref/result_blob.html

                                                                                                                          func (*SQLiteContext) ResultInt

                                                                                                                          func (c *SQLiteContext) ResultInt(i int)

                                                                                                                            ResultInt sets the result of an SQL function. See: sqlite3_result_int, http://sqlite.org/c3ref/result_blob.html

                                                                                                                            func (*SQLiteContext) ResultInt64

                                                                                                                            func (c *SQLiteContext) ResultInt64(i int64)

                                                                                                                              ResultInt64 sets the result of an SQL function. See: sqlite3_result_int64, http://sqlite.org/c3ref/result_blob.html

                                                                                                                              func (*SQLiteContext) ResultNull

                                                                                                                              func (c *SQLiteContext) ResultNull()

                                                                                                                                ResultNull sets the result of an SQL function. See: sqlite3_result_null, http://sqlite.org/c3ref/result_blob.html

                                                                                                                                func (*SQLiteContext) ResultText

                                                                                                                                func (c *SQLiteContext) ResultText(s string)

                                                                                                                                  ResultText sets the result of an SQL function. See: sqlite3_result_text, http://sqlite.org/c3ref/result_blob.html

                                                                                                                                  func (*SQLiteContext) ResultZeroblob

                                                                                                                                  func (c *SQLiteContext) ResultZeroblob(n int)

                                                                                                                                    ResultZeroblob sets the result of an SQL function. See: sqlite3_result_zeroblob, http://sqlite.org/c3ref/result_blob.html

                                                                                                                                    type SQLiteDriver

                                                                                                                                    type SQLiteDriver struct {
                                                                                                                                    	Extensions  []string
                                                                                                                                    	ConnectHook func(*SQLiteConn) error
                                                                                                                                    }

                                                                                                                                      SQLiteDriver implements driver.Driver.

                                                                                                                                      func (*SQLiteDriver) Open

                                                                                                                                      func (d *SQLiteDriver) Open(dsn string) (driver.Conn, error)

                                                                                                                                        Open database and return a new connection.

                                                                                                                                        A pragma can take either zero or one argument. The argument is may be either in parentheses or it may be separated from the pragma name by an equal sign. The two syntaxes yield identical results. In many pragmas, the argument is a boolean. The boolean can be one of:

                                                                                                                                        1 yes true on
                                                                                                                                        0 no false off
                                                                                                                                        

                                                                                                                                        You can specify a DSN string using a URI as the filename.

                                                                                                                                        test.db
                                                                                                                                        file:test.db?cache=shared&mode=memory
                                                                                                                                        :memory:
                                                                                                                                        file::memory:
                                                                                                                                        
                                                                                                                                        mode
                                                                                                                                          Access mode of the database.
                                                                                                                                          https://www.sqlite.org/c3ref/open.html
                                                                                                                                          Values:
                                                                                                                                           - ro
                                                                                                                                           - rw
                                                                                                                                           - rwc
                                                                                                                                           - memory
                                                                                                                                        
                                                                                                                                        cache
                                                                                                                                          SQLite Shared-Cache Mode
                                                                                                                                          https://www.sqlite.org/sharedcache.html
                                                                                                                                          Values:
                                                                                                                                            - shared
                                                                                                                                            - private
                                                                                                                                        
                                                                                                                                        immutable=Boolean
                                                                                                                                          The immutable parameter is a boolean query parameter that indicates
                                                                                                                                          that the database file is stored on read-only media. When immutable is set,
                                                                                                                                          SQLite assumes that the database file cannot be changed,
                                                                                                                                          even by a process with higher privilege,
                                                                                                                                          and so the database is opened read-only and all locking and change detection is disabled.
                                                                                                                                          Caution: Setting the immutable property on a database file that
                                                                                                                                          does in fact change can result in incorrect query results and/or SQLITE_CORRUPT errors.
                                                                                                                                        

                                                                                                                                        go-sqlite3 adds the following query parameters to those used by SQLite:

                                                                                                                                        _loc=XXX
                                                                                                                                          Specify location of time format. It's possible to specify "auto".
                                                                                                                                        
                                                                                                                                        _mutex=XXX
                                                                                                                                          Specify mutex mode. XXX can be "no", "full".
                                                                                                                                        
                                                                                                                                        _txlock=XXX
                                                                                                                                          Specify locking behavior for transactions.  XXX can be "immediate",
                                                                                                                                          "deferred", "exclusive".
                                                                                                                                        
                                                                                                                                        _auto_vacuum=X | _vacuum=X
                                                                                                                                          0 | none - Auto Vacuum disabled
                                                                                                                                          1 | full - Auto Vacuum FULL
                                                                                                                                          2 | incremental - Auto Vacuum Incremental
                                                                                                                                        
                                                                                                                                        _busy_timeout=XXX"| _timeout=XXX
                                                                                                                                          Specify value for sqlite3_busy_timeout.
                                                                                                                                        
                                                                                                                                        _case_sensitive_like=Boolean | _cslike=Boolean
                                                                                                                                          https://www.sqlite.org/pragma.html#pragma_case_sensitive_like
                                                                                                                                          Default or disabled the LIKE operation is case-insensitive.
                                                                                                                                          When enabling this options behaviour of LIKE will become case-sensitive.
                                                                                                                                        
                                                                                                                                        _defer_foreign_keys=Boolean | _defer_fk=Boolean
                                                                                                                                          Defer Foreign Keys until outermost transaction is committed.
                                                                                                                                        
                                                                                                                                        _foreign_keys=Boolean | _fk=Boolean
                                                                                                                                          Enable or disable enforcement of foreign keys.
                                                                                                                                        
                                                                                                                                        _ignore_check_constraints=Boolean
                                                                                                                                          This pragma enables or disables the enforcement of CHECK constraints.
                                                                                                                                          The default setting is off, meaning that CHECK constraints are enforced by default.
                                                                                                                                        
                                                                                                                                        _journal_mode=MODE | _journal=MODE
                                                                                                                                          Set journal mode for the databases associated with the current connection.
                                                                                                                                          https://www.sqlite.org/pragma.html#pragma_journal_mode
                                                                                                                                        
                                                                                                                                        _locking_mode=X | _locking=X
                                                                                                                                          Sets the database connection locking-mode.
                                                                                                                                          The locking-mode is either NORMAL or EXCLUSIVE.
                                                                                                                                          https://www.sqlite.org/pragma.html#pragma_locking_mode
                                                                                                                                        
                                                                                                                                        _query_only=Boolean
                                                                                                                                          The query_only pragma prevents all changes to database files when enabled.
                                                                                                                                        
                                                                                                                                        _recursive_triggers=Boolean | _rt=Boolean
                                                                                                                                          Enable or disable recursive triggers.
                                                                                                                                        
                                                                                                                                        _secure_delete=Boolean|FAST
                                                                                                                                          When secure_delete is on, SQLite overwrites deleted content with zeros.
                                                                                                                                          https://www.sqlite.org/pragma.html#pragma_secure_delete
                                                                                                                                        
                                                                                                                                        _synchronous=X | _sync=X
                                                                                                                                          Change the setting of the "synchronous" flag.
                                                                                                                                          https://www.sqlite.org/pragma.html#pragma_synchronous
                                                                                                                                        
                                                                                                                                        _writable_schema=Boolean
                                                                                                                                          When this pragma is on, the SQLITE_MASTER tables in which database
                                                                                                                                          can be changed using ordinary UPDATE, INSERT, and DELETE statements.
                                                                                                                                          Warning: misuse of this pragma can easily result in a corrupt database file.
                                                                                                                                        

                                                                                                                                        type SQLitePreUpdateData

                                                                                                                                        type SQLitePreUpdateData struct {
                                                                                                                                        	Conn         *SQLiteConn
                                                                                                                                        	Op           int
                                                                                                                                        	DatabaseName string
                                                                                                                                        	TableName    string
                                                                                                                                        	OldRowID     int64
                                                                                                                                        	NewRowID     int64
                                                                                                                                        }

                                                                                                                                          SQLitePreUpdateData represents all of the data available during a pre-update hook call.

                                                                                                                                          type SQLiteResult

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

                                                                                                                                            SQLiteResult implements sql.Result.

                                                                                                                                            func (*SQLiteResult) LastInsertId

                                                                                                                                            func (r *SQLiteResult) LastInsertId() (int64, error)

                                                                                                                                              LastInsertId return last inserted ID.

                                                                                                                                              func (*SQLiteResult) RowsAffected

                                                                                                                                              func (r *SQLiteResult) RowsAffected() (int64, error)

                                                                                                                                                RowsAffected return how many rows affected.

                                                                                                                                                type SQLiteRows

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

                                                                                                                                                  SQLiteRows implements driver.Rows.

                                                                                                                                                  func (*SQLiteRows) Close

                                                                                                                                                  func (rc *SQLiteRows) Close() error

                                                                                                                                                    Close the rows.

                                                                                                                                                    func (*SQLiteRows) ColumnTypeDatabaseTypeName

                                                                                                                                                    func (rc *SQLiteRows) ColumnTypeDatabaseTypeName(i int) string

                                                                                                                                                      ColumnTypeDatabaseTypeName implement RowsColumnTypeDatabaseTypeName.

                                                                                                                                                      func (*SQLiteRows) ColumnTypeScanType

                                                                                                                                                      func (rc *SQLiteRows) ColumnTypeScanType(i int) reflect.Type

                                                                                                                                                        ColumnTypeScanType implement RowsColumnTypeScanType.

                                                                                                                                                        func (*SQLiteRows) Columns

                                                                                                                                                        func (rc *SQLiteRows) Columns() []string

                                                                                                                                                          Columns return column names.

                                                                                                                                                          func (*SQLiteRows) DeclTypes

                                                                                                                                                          func (rc *SQLiteRows) DeclTypes() []string

                                                                                                                                                            DeclTypes return column types.

                                                                                                                                                            func (*SQLiteRows) Next

                                                                                                                                                            func (rc *SQLiteRows) Next(dest []driver.Value) error

                                                                                                                                                              Next move cursor to next. Attempts to honor context timeout from QueryContext call.

                                                                                                                                                              type SQLiteStmt

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

                                                                                                                                                                SQLiteStmt implements driver.Stmt.

                                                                                                                                                                func (*SQLiteStmt) Close

                                                                                                                                                                func (s *SQLiteStmt) Close() error

                                                                                                                                                                  Close the statement.

                                                                                                                                                                  func (*SQLiteStmt) Exec

                                                                                                                                                                  func (s *SQLiteStmt) Exec(args []driver.Value) (driver.Result, error)

                                                                                                                                                                    Exec execute the statement with arguments. Return result object.

                                                                                                                                                                    func (*SQLiteStmt) ExecContext

                                                                                                                                                                    func (s *SQLiteStmt) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error)

                                                                                                                                                                      ExecContext implement ExecerContext.

                                                                                                                                                                      func (*SQLiteStmt) NumInput

                                                                                                                                                                      func (s *SQLiteStmt) NumInput() int

                                                                                                                                                                        NumInput return a number of parameters.

                                                                                                                                                                        func (*SQLiteStmt) Query

                                                                                                                                                                        func (s *SQLiteStmt) Query(args []driver.Value) (driver.Rows, error)

                                                                                                                                                                          Query the statement with arguments. Return records.

                                                                                                                                                                          func (*SQLiteStmt) QueryContext

                                                                                                                                                                          func (s *SQLiteStmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error)

                                                                                                                                                                            QueryContext implement QueryerContext.

                                                                                                                                                                            type SQLiteTx

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

                                                                                                                                                                              SQLiteTx implements driver.Tx.

                                                                                                                                                                              func (*SQLiteTx) Commit

                                                                                                                                                                              func (tx *SQLiteTx) Commit() error

                                                                                                                                                                                Commit transaction.

                                                                                                                                                                                func (*SQLiteTx) Rollback

                                                                                                                                                                                func (tx *SQLiteTx) Rollback() error

                                                                                                                                                                                  Rollback transaction.

                                                                                                                                                                                  Directories

                                                                                                                                                                                  Path Synopsis
                                                                                                                                                                                  _example
                                                                                                                                                                                  Package upgrade is a dummy package to ensure package can be loaded This file is to avoid the following error: can't load package: package go-sqlite3/upgrade: build constraints exclude all Go files in go-sqlite3\upgrade
                                                                                                                                                                                  Package upgrade is a dummy package to ensure package can be loaded This file is to avoid the following error: can't load package: package go-sqlite3/upgrade: build constraints exclude all Go files in go-sqlite3\upgrade