README
¶
go-sqlite3
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
- go-sqlite3
- Description
- Installation
- API Reference
- Connection String
- Features
- Compilation
- ARM
- Cross Compile
- Google Cloud Platform
- User Authentication
- Extensions
- FAQ
- License
- Author
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:
0nofalseoff1yestrueon
| 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 |
|
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 |
|
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 |
|
For more information see PRAGMA journal_mode |
| Locking Mode | _locking_mode | _locking |
|
For more information see PRAGMA locking_mode |
| Mode | mode |
|
Access Mode of the database. For more information see SQLite Open |
| Mutex Locking | _mutex |
|
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 |
|
Set cache mode for more information see sqlite.org |
| Synchronous | _synchronous | _sync |
|
For more information see PRAGMA synchronous |
| Time Zone Location | _loc |
auto | Specify location of time format. |
| Transaction Lock | _txlock |
|
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.
|
| 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.
- Install a Windows
gcctoolchain. - Add the
binfolders to the Windows path if the installer did not do this by default. - Open a terminal for the TDM-GCC toolchain, can be found in the Windows Start menu.
- 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 -fPICWhen receiving a compile time error referencing recompile with
-FPICthen 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-sqlite3throws compilation error.gccthrows:internal compiler errorRemove 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
// 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=autoin SQLite3 filename schema likefile: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 tableerror?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 errorDot 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 lockedWhen you get a database is locked. Please use the following options.
Add to DSN:
cache=sharedExample:
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
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
- Variables
- func CryptEncoderSHA1(pass []byte, hash interface{}) []byte
- func CryptEncoderSHA256(pass []byte, hash interface{}) []byte
- func CryptEncoderSHA384(pass []byte, hash interface{}) []byte
- func CryptEncoderSHA512(pass []byte, hash interface{}) []byte
- func CryptEncoderSSHA1(salt string) func(pass []byte, hash interface{}) []byte
- func CryptEncoderSSHA256(salt string) func(pass []byte, hash interface{}) []byte
- func CryptEncoderSSHA384(salt string) func(pass []byte, hash interface{}) []byte
- func CryptEncoderSSHA512(salt string) func(pass []byte, hash interface{}) []byte
- func Version() (libVersion string, libVersionNumber int, sourceID string)
- type ErrNo
- type ErrNoExtended
- type Error
- type SQLiteBackup
- type SQLiteConn
- func (c *SQLiteConn) AuthEnabled() (exists bool)
- func (c *SQLiteConn) AuthUserAdd(username, password string, admin bool) error
- func (c *SQLiteConn) AuthUserChange(username, password string, admin bool) error
- func (c *SQLiteConn) AuthUserDelete(username string) error
- func (c *SQLiteConn) Authenticate(username, password string) error
- func (c *SQLiteConn) AutoCommit() bool
- func (destConn *SQLiteConn) Backup(dest string, srcConn *SQLiteConn, src string) (*SQLiteBackup, error)
- func (c *SQLiteConn) Begin() (driver.Tx, error)
- func (c *SQLiteConn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error)
- func (c *SQLiteConn) Close() error
- func (c *SQLiteConn) Exec(query string, args []driver.Value) (driver.Result, error)
- func (c *SQLiteConn) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error)
- func (c *SQLiteConn) GetFilename(schemaName string) string
- func (c *SQLiteConn) GetLimit(id int) int
- func (c *SQLiteConn) LoadExtension(lib string, entry string) error
- func (c *SQLiteConn) Ping(ctx context.Context) error
- func (c *SQLiteConn) Prepare(query string) (driver.Stmt, error)
- func (c *SQLiteConn) PrepareContext(ctx context.Context, query string) (driver.Stmt, error)
- func (c *SQLiteConn) Query(query string, args []driver.Value) (driver.Rows, error)
- func (c *SQLiteConn) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error)
- func (c *SQLiteConn) RegisterAggregator(name string, impl interface{}, pure bool) error
- func (c *SQLiteConn) RegisterAuthorizer(callback func(int, string, string, string) int)
- func (c *SQLiteConn) RegisterCollation(name string, cmp func(string, string) int) error
- func (c *SQLiteConn) RegisterCommitHook(callback func() int)
- func (c *SQLiteConn) RegisterFunc(name string, impl interface{}, pure bool) error
- func (c *SQLiteConn) RegisterPreUpdateHook(callback func(SQLitePreUpdateData))
- func (c *SQLiteConn) RegisterRollbackHook(callback func())
- func (c *SQLiteConn) RegisterUpdateHook(callback func(int, string, string, int64))
- func (c *SQLiteConn) SetLimit(id int, newVal int) int
- type SQLiteContext
- func (c *SQLiteContext) ResultBlob(b []byte)
- func (c *SQLiteContext) ResultBool(b bool)
- func (c *SQLiteContext) ResultDouble(d float64)
- func (c *SQLiteContext) ResultInt(i int)
- func (c *SQLiteContext) ResultInt64(i int64)
- func (c *SQLiteContext) ResultNull()
- func (c *SQLiteContext) ResultText(s string)
- func (c *SQLiteContext) ResultZeroblob(n int)
- type SQLiteDriver
- type SQLitePreUpdateData
- type SQLiteResult
- type SQLiteRows
- type SQLiteStmt
- func (s *SQLiteStmt) Close() error
- func (s *SQLiteStmt) Exec(args []driver.Value) (driver.Result, error)
- func (s *SQLiteStmt) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error)
- func (s *SQLiteStmt) NumInput() int
- func (s *SQLiteStmt) Query(args []driver.Value) (driver.Rows, error)
- func (s *SQLiteStmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error)
- func (s *SQLiteStmt) Readonly() bool
- type SQLiteTx
Constants ¶
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 )
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
const ErrNoMask C.int = 0xff
ErrNoMask is mask code.
Variables ¶
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
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) 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
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 ¶
CryptEncoderSHA1 encodes a password with SHA1
func CryptEncoderSHA256 ¶
CryptEncoderSHA256 encodes a password with SHA256
func CryptEncoderSHA384 ¶
CryptEncoderSHA384 encodes a password with SHA384
func CryptEncoderSHA512 ¶
CryptEncoderSHA512 encodes a password with SHA512
func CryptEncoderSSHA1 ¶
CryptEncoderSSHA1 encodes a password with SHA1 with the configured salt.
func CryptEncoderSSHA256 ¶
CryptEncoderSSHA256 encodes a password with SHA256 with the configured salt
func CryptEncoderSSHA384 ¶
CryptEncoderSSHA384 encodes a password with SHA384 with the configured salt
func CryptEncoderSSHA512 ¶
CryptEncoderSSHA512 encodes a password with SHA512 with the configured salt
Types ¶
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.
type SQLiteBackup ¶
type SQLiteBackup struct {
// contains filtered or unexported fields
}
SQLiteBackup implement interface of 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) 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 ¶
PrepareContext implement ConnPrepareContext.
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 ¶
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 ¶
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) 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) DeclTypes ¶
func (rc *SQLiteRows) DeclTypes() []string
DeclTypes return column types.
type SQLiteStmt ¶
type SQLiteStmt struct {
// contains filtered or unexported fields
}
SQLiteStmt implements driver.Stmt.
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) QueryContext ¶
func (s *SQLiteStmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error)
QueryContext implement QueryerContext.
func (*SQLiteStmt) Readonly ¶
func (s *SQLiteStmt) Readonly() bool
Readonly reports if this statement is considered readonly by SQLite.
Source Files
¶
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 |
Valid