// Copyright (C) 2019 Yasuhiro Matsumoto <[email protected]>.

// Copyright (C) 2018 G.J.R. Timmer <[email protected]>.

//

// Use of this source code is governed by an MIT-style

// license that can be found in the LICENSE file.

//go:build cgo

// +build cgo

package sqlite3

/*

#cgo CFLAGS: -std=gnu99

#cgo CFLAGS: -DSQLITE_ENABLE_RTREE

#cgo CFLAGS: -DSQLITE_THREADSAFE=1

#cgo CFLAGS: -DHAVE_USLEEP=1

#cgo CFLAGS: -DSQLITE_ENABLE_FTS3

#cgo CFLAGS: -DSQLITE_ENABLE_FTS3_PARENTHESIS

#cgo CFLAGS: -DSQLITE_TRACE_SIZE_LIMIT=15

#cgo CFLAGS: -DSQLITE_OMIT_DEPRECATED

#cgo CFLAGS: -DSQLITE_DEFAULT_WAL_SYNCHRONOUS=1

#cgo CFLAGS: -DSQLITE_ENABLE_UPDATE_DELETE_LIMIT

#cgo CFLAGS: -Wno-deprecated-declarations

#cgo openbsd CFLAGS: -I/usr/local/include

#cgo openbsd LDFLAGS: -L/usr/local/lib

#ifndef USE_LIBSQLITE3

#include "sqlite3-binding.h"

#else

#include <sqlite3.h>

#endif

#include <stdlib.h>

#include <string.h>

#ifdef __CYGWIN__

# include <errno.h>

#endif

#ifndef SQLITE_OPEN_READWRITE

# define SQLITE_OPEN_READWRITE 0

#endif

#ifndef SQLITE_OPEN_FULLMUTEX

# define SQLITE_OPEN_FULLMUTEX 0

#endif

#ifndef SQLITE_DETERMINISTIC

# define SQLITE_DETERMINISTIC 0

#endif

#if defined(HAVE_PREAD64) && defined(HAVE_PWRITE64)

# undef USE_PREAD

# undef USE_PWRITE

# define USE_PREAD64 1

# define USE_PWRITE64 1

#elif defined(HAVE_PREAD) && defined(HAVE_PWRITE)

# undef USE_PREAD

# undef USE_PWRITE

# define USE_PREAD64 1

# define USE_PWRITE64 1

#endif

static int

_sqlite3_open_v2(const char *filename, sqlite3 **ppDb, int flags, const char *zVfs) {

#ifdef SQLITE_OPEN_URI

return sqlite3_open_v2(filename, ppDb, flags | SQLITE_OPEN_URI, zVfs);

#else

return sqlite3_open_v2(filename, ppDb, flags, zVfs);

#endif

}

static int

_sqlite3_bind_text(sqlite3_stmt *stmt, int n, char *p, int np) {

return sqlite3_bind_text(stmt, n, p, np, SQLITE_TRANSIENT);

}

static int

_sqlite3_bind_blob(sqlite3_stmt *stmt, int n, void *p, int np) {

return sqlite3_bind_blob(stmt, n, p, np, SQLITE_TRANSIENT);

}

#include <stdio.h>

#include <stdint.h>

static int

_sqlite3_exec(sqlite3* db, const char* pcmd, long long* rowid, long long* changes)

{

int rv = sqlite3_exec(db, pcmd, 0, 0, 0);

*rowid = (long long) sqlite3_last_insert_rowid(db);

*changes = (long long) sqlite3_changes(db);

return rv;

}

#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY

extern int _sqlite3_step_blocking(sqlite3_stmt *stmt);

extern int _sqlite3_step_row_blocking(sqlite3_stmt* stmt, long long* rowid, long long* changes);

extern int _sqlite3_prepare_v2_blocking(sqlite3 *db, const char *zSql, int nBytes, sqlite3_stmt **ppStmt, const char **pzTail);

static int

_sqlite3_step_internal(sqlite3_stmt *stmt)

{

return _sqlite3_step_blocking(stmt);

}

static int

_sqlite3_step_row_internal(sqlite3_stmt* stmt, long long* rowid, long long* changes)

{

return _sqlite3_step_row_blocking(stmt, rowid, changes);

}

static int

_sqlite3_prepare_v2_internal(sqlite3 *db, const char *zSql, int nBytes, sqlite3_stmt **ppStmt, const char **pzTail)

{

return _sqlite3_prepare_v2_blocking(db, zSql, nBytes, ppStmt, pzTail);

}

#else

static int

_sqlite3_step_internal(sqlite3_stmt *stmt)

{

return sqlite3_step(stmt);

}

static int

_sqlite3_step_row_internal(sqlite3_stmt* stmt, long long* rowid, long long* changes)

{

int rv = sqlite3_step(stmt);

sqlite3* db = sqlite3_db_handle(stmt);

*rowid = (long long) sqlite3_last_insert_rowid(db);

*changes = (long long) sqlite3_changes(db);

return rv;

}

static int

_sqlite3_prepare_v2_internal(sqlite3 *db, const char *zSql, int nBytes, sqlite3_stmt **ppStmt, const char **pzTail)

{

return sqlite3_prepare_v2(db, zSql, nBytes, ppStmt, pzTail);

}

#endif

void _sqlite3_result_text(sqlite3_context* ctx, const char* s) {

sqlite3_result_text(ctx, s, -1, &free);

}

void _sqlite3_result_blob(sqlite3_context* ctx, const void* b, int l) {

sqlite3_result_blob(ctx, b, l, SQLITE_TRANSIENT);

}

int _sqlite3_create_function(

sqlite3 *db,

const char *zFunctionName,

int nArg,

int eTextRep,

uintptr_t pApp,

void (*xFunc)(sqlite3_context*,int,sqlite3_value**),

void (*xStep)(sqlite3_context*,int,sqlite3_value**),

void (*xFinal)(sqlite3_context*)

) {

return sqlite3_create_function(db, zFunctionName, nArg, eTextRep, (void*) pApp, xFunc, xStep, xFinal);

}

void callbackTrampoline(sqlite3_context*, int, sqlite3_value**);

void stepTrampoline(sqlite3_context*, int, sqlite3_value**);

void doneTrampoline(sqlite3_context*);

int compareTrampoline(void*, int, char*, int, char*);

int commitHookTrampoline(void*);

void rollbackHookTrampoline(void*);

void updateHookTrampoline(void*, int, char*, char*, sqlite3_int64);

int authorizerTrampoline(void*, int, char*, char*, char*, char*);

#ifdef SQLITE_LIMIT_WORKER_THREADS

# define _SQLITE_HAS_LIMIT

# define SQLITE_LIMIT_LENGTH 0

# define SQLITE_LIMIT_SQL_LENGTH 1

# define SQLITE_LIMIT_COLUMN 2

# define SQLITE_LIMIT_EXPR_DEPTH 3

# define SQLITE_LIMIT_COMPOUND_SELECT 4

# define SQLITE_LIMIT_VDBE_OP 5

# define SQLITE_LIMIT_FUNCTION_ARG 6

# define SQLITE_LIMIT_ATTACHED 7

# define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8

# define SQLITE_LIMIT_VARIABLE_NUMBER 9

# define SQLITE_LIMIT_TRIGGER_DEPTH 10

# define SQLITE_LIMIT_WORKER_THREADS 11

# else

# define SQLITE_LIMIT_WORKER_THREADS 11

#endif

static int _sqlite3_limit(sqlite3* db, int limitId, int newLimit) {

#ifndef _SQLITE_HAS_LIMIT

return -1;

#else

return sqlite3_limit(db, limitId, newLimit);

#endif

}

#if SQLITE_VERSION_NUMBER < 3012000

static int sqlite3_system_errno(sqlite3 *db) {

return 0;

}

#endif

*/

import "C"

import (

"context"

"database/sql"

"database/sql/driver"

"errors"

"fmt"

"io"

"net/url"

"reflect"

"runtime"

"strconv"

"strings"

"sync"

"syscall"

"time"

"unsafe"

)

// 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.

var SQLiteTimestampFormats = []string{

// By default, store timestamps with whatever timezone they come with.

// When parsed, they will be returned with the same timezone.

"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",

}

const (

columnDate string = "date"

columnDatetime string = "datetime"

columnTimestamp string = "timestamp"

)

// This variable can be replaced with -ldflags like below:

// go build -ldflags="-X 'github.com/thinkgos/go-sqlcipher.driverName=my-sqlite3'"

var driverName = "sqlite3"

func init() {

if driverName != "" {

sql.Register(driverName, &SQLiteDriver{})

}

}

// Version returns SQLite library version information.

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

libVersion = C.GoString(C.sqlite3_libversion())

libVersionNumber = int(C.sqlite3_libversion_number())

sourceID = C.GoString(C.sqlite3_sourceid())

return libVersion, libVersionNumber, sourceID

}

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

/*SQLITE_RECURSIVE = C.SQLITE_RECURSIVE*/

)

// Standard File Control Opcodes

// See: https://www.sqlite.org/c3ref/c_fcntl_begin_atomic_write.html

const (

SQLITE_FCNTL_LOCKSTATE = int(1)

SQLITE_FCNTL_GET_LOCKPROXYFILE = int(2)

SQLITE_FCNTL_SET_LOCKPROXYFILE = int(3)

SQLITE_FCNTL_LAST_ERRNO = int(4)

SQLITE_FCNTL_SIZE_HINT = int(5)

SQLITE_FCNTL_CHUNK_SIZE = int(6)

SQLITE_FCNTL_FILE_POINTER = int(7)

SQLITE_FCNTL_SYNC_OMITTED = int(8)

SQLITE_FCNTL_WIN32_AV_RETRY = int(9)

SQLITE_FCNTL_PERSIST_WAL = int(10)

SQLITE_FCNTL_OVERWRITE = int(11)

SQLITE_FCNTL_VFSNAME = int(12)

SQLITE_FCNTL_POWERSAFE_OVERWRITE = int(13)

SQLITE_FCNTL_PRAGMA = int(14)

SQLITE_FCNTL_BUSYHANDLER = int(15)

SQLITE_FCNTL_TEMPFILENAME = int(16)

SQLITE_FCNTL_MMAP_SIZE = int(18)

SQLITE_FCNTL_TRACE = int(19)

SQLITE_FCNTL_HAS_MOVED = int(20)

SQLITE_FCNTL_SYNC = int(21)

SQLITE_FCNTL_COMMIT_PHASETWO = int(22)

SQLITE_FCNTL_WIN32_SET_HANDLE = int(23)

SQLITE_FCNTL_WAL_BLOCK = int(24)

SQLITE_FCNTL_ZIPVFS = int(25)

SQLITE_FCNTL_RBU = int(26)

SQLITE_FCNTL_VFS_POINTER = int(27)

SQLITE_FCNTL_JOURNAL_POINTER = int(28)

SQLITE_FCNTL_WIN32_GET_HANDLE = int(29)

SQLITE_FCNTL_PDB = int(30)

SQLITE_FCNTL_BEGIN_ATOMIC_WRITE = int(31)

SQLITE_FCNTL_COMMIT_ATOMIC_WRITE = int(32)

SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE = int(33)

SQLITE_FCNTL_LOCK_TIMEOUT = int(34)

SQLITE_FCNTL_DATA_VERSION = int(35)

SQLITE_FCNTL_SIZE_LIMIT = int(36)

SQLITE_FCNTL_CKPT_DONE = int(37)

SQLITE_FCNTL_RESERVE_BYTES = int(38)

SQLITE_FCNTL_CKPT_START = int(39)

SQLITE_FCNTL_EXTERNAL_READER = int(40)

SQLITE_FCNTL_CKSM_FILE = int(41)

)

// SQLiteDriver implements driver.Driver.

type SQLiteDriver struct {

Extensions []string

ConnectHook func(*SQLiteConn) error

}

// SQLiteConn implements driver.Conn.

type SQLiteConn struct {

mu sync.Mutex

db *C.sqlite3

loc *time.Location

txlock string

funcs []*functionInfo

aggregators []*aggInfo

}

// SQLiteTx implements driver.Tx.

type SQLiteTx struct {

c *SQLiteConn

}

// SQLiteStmt implements driver.Stmt.

type SQLiteStmt struct {

mu sync.Mutex

c *SQLiteConn

s *C.sqlite3_stmt

t string

closed bool

cls bool // True if the statement was created by SQLiteConn.Query

}

// SQLiteResult implements sql.Result.

type SQLiteResult struct {

id int64

changes int64

}

// SQLiteRows implements driver.Rows.

type SQLiteRows struct {

s *SQLiteStmt

nc int32 // Number of columns

cls bool // True if we need to close the parent statement in Close

cols []string

decltype []string

ctx context.Context // no better alternative to pass context into Next() method

closemu sync.Mutex

}

type functionInfo struct {

f reflect.Value

argConverters []callbackArgConverter

variadicConverter callbackArgConverter

retConverter callbackRetConverter

}

func (fi *functionInfo) Call(ctx *C.sqlite3_context, argv []*C.sqlite3_value) {

args, err := callbackConvertArgs(argv, fi.argConverters, fi.variadicConverter)

if err != nil {

callbackError(ctx, err)

return

}

ret := fi.f.Call(args)

if len(ret) == 2 && ret[1].Interface() != nil {

callbackError(ctx, ret[1].Interface().(error))

return

}

err = fi.retConverter(ctx, ret[0])

if err != nil {

callbackError(ctx, err)

return

}

}

type aggInfo struct {

constructor reflect.Value

// Active aggregator objects for aggregations in flight. The

// aggregators are indexed by a counter stored in the aggregation

// user data space provided by sqlite.

active map[int64]reflect.Value

next int64

stepArgConverters []callbackArgConverter

stepVariadicConverter callbackArgConverter

doneRetConverter callbackRetConverter

}

func (ai *aggInfo) agg(ctx *C.sqlite3_context) (int64, reflect.Value, error) {

aggIdx := (*int64)(C.sqlite3_aggregate_context(ctx, C.int(8)))

if *aggIdx == 0 {

*aggIdx = ai.next

ret := ai.constructor.Call(nil)

if len(ret) == 2 && ret[1].Interface() != nil {

return 0, reflect.Value{}, ret[1].Interface().(error)

}

if ret[0].IsNil() {

return 0, reflect.Value{}, errors.New("aggregator constructor returned nil state")

}

ai.next++

ai.active[*aggIdx] = ret[0]

}

return *aggIdx, ai.active[*aggIdx], nil

}

func (ai *aggInfo) Step(ctx *C.sqlite3_context, argv []*C.sqlite3_value) {

_, agg, err := ai.agg(ctx)

if err != nil {

callbackError(ctx, err)

return

}

args, err := callbackConvertArgs(argv, ai.stepArgConverters, ai.stepVariadicConverter)

if err != nil {

callbackError(ctx, err)

return

}

ret := agg.MethodByName("Step").Call(args)

if len(ret) == 1 && ret[0].Interface() != nil {

callbackError(ctx, ret[0].Interface().(error))

return

}

}

func (ai *aggInfo) Done(ctx *C.sqlite3_context) {

idx, agg, err := ai.agg(ctx)

if err != nil {

callbackError(ctx, err)

return

}

defer func() { delete(ai.active, idx) }()

ret := agg.MethodByName("Done").Call(nil)

if len(ret) == 2 && ret[1].Interface() != nil {

callbackError(ctx, ret[1].Interface().(error))

return

}

err = ai.doneRetConverter(ctx, ret[0])

if err != nil {

callbackError(ctx, err)

return

}

}

// Commit transaction.

func (tx *SQLiteTx) Commit() error {

_, err := tx.c.exec(context.Background(), "COMMIT", nil)

if err != nil {

// sqlite3 may leave the transaction open in this scenario.

// However, database/sql considers the transaction complete once we

// return from Commit() - we must clean up to honour its semantics.

// We don't know if the ROLLBACK is strictly necessary, but according

// to sqlite's docs, there is no harm in calling ROLLBACK unnecessarily.

tx.c.exec(context.Background(), "ROLLBACK", nil)

}

return err

}

// Rollback transaction.

func (tx *SQLiteTx) Rollback() error {

_, err := tx.c.exec(context.Background(), "ROLLBACK", nil)

return err

}

// 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 (c *SQLiteConn) RegisterCollation(name string, cmp func(string, string) int) error {

handle := newHandle(c, cmp)

cname := C.CString(name)

defer C.free(unsafe.Pointer(cname))

rv := C.sqlite3_create_collation(c.db, cname, C.SQLITE_UTF8, handle, (*[0]byte)(unsafe.Pointer(C.compareTrampoline)))

if rv != C.SQLITE_OK {

return c.lastError()

}

return nil

}

// 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 (c *SQLiteConn) RegisterCommitHook(callback func() int) {

if callback == nil {

C.sqlite3_commit_hook(c.db, nil, nil)

} else {

C.sqlite3_commit_hook(c.db, (*[0]byte)(C.commitHookTrampoline), newHandle(c, callback))

}

}

// 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 (c *SQLiteConn) RegisterRollbackHook(callback func()) {

if callback == nil {

C.sqlite3_rollback_hook(c.db, nil, nil)

} else {

C.sqlite3_rollback_hook(c.db, (*[0]byte)(C.rollbackHookTrampoline), newHandle(c, callback))

}

}

// 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 (c *SQLiteConn) RegisterUpdateHook(callback func(int, string, string, int64)) {

if callback == nil {

C.sqlite3_update_hook(c.db, nil, nil)

} else {

C.sqlite3_update_hook(c.db, (*[0]byte)(C.updateHookTrampoline), newHandle(c, callback))

}

}

// 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 (c *SQLiteConn) RegisterAuthorizer(callback func(int, string, string, string) int) {

if callback == nil {

C.sqlite3_set_authorizer(c.db, nil, nil)

} else {

C.sqlite3_set_authorizer(c.db, (*[0]byte)(C.authorizerTrampoline), newHandle(c, callback))

}

}

// 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 any.

// any 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 (c *SQLiteConn) RegisterFunc(name string, impl any, pure bool) error {

var fi functionInfo

fi.f = reflect.ValueOf(impl)

t := fi.f.Type()

if t.Kind() != reflect.Func {

return errors.New("Non-function passed to RegisterFunc")

}

if t.NumOut() != 1 && t.NumOut() != 2 {

return errors.New("SQLite functions must return 1 or 2 values")

}

if t.NumOut() == 2 && !t.Out(1).Implements(reflect.TypeOf((*error)(nil)).Elem()) {

return errors.New("Second return value of SQLite function must be error")

}

numArgs := t.NumIn()

if t.IsVariadic() {

numArgs--

}

for i := 0; i < numArgs; i++ {

conv, err := callbackArg(t.In(i))

if err != nil {

return err

}

fi.argConverters = append(fi.argConverters, conv)

}

if t.IsVariadic() {

conv, err := callbackArg(t.In(numArgs).Elem())

if err != nil {

return err

}

fi.variadicConverter = conv

// Pass -1 to sqlite so that it allows any number of

// arguments. The call helper verifies that the minimum number

// of arguments is present for variadic functions.

numArgs = -1

}

conv, err := callbackRet(t.Out(0))

if err != nil {

return err

}

fi.retConverter = conv

// fi must outlast the database connection, or we'll have dangling pointers.

c.funcs = append(c.funcs, &fi)

cname := C.CString(name)

defer C.free(unsafe.Pointer(cname))

opts := C.SQLITE_UTF8

if pure {

opts |= C.SQLITE_DETERMINISTIC

}

rv := sqlite3CreateFunction(c.db, cname, C.int(numArgs), C.int(opts), newHandle(c, &fi), C.callbackTrampoline, nil, nil)

if rv != C.SQLITE_OK {

return c.lastError()

}

return nil

}

func sqlite3CreateFunction(db *C.sqlite3, zFunctionName *C.char, nArg C.int, eTextRep C.int, pApp unsafe.Pointer, xFunc unsafe.Pointer, xStep unsafe.Pointer, xFinal unsafe.Pointer) C.int {

return C._sqlite3_create_function(db, zFunctionName, nArg, eTextRep, C.uintptr_t(uintptr(pApp)), (*[0]byte)(xFunc), (*[0]byte)(xStep), (*[0]byte)(xFinal))

}

// 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 (c *SQLiteConn) RegisterAggregator(name string, impl any, pure bool) error {

var ai aggInfo

ai.constructor = reflect.ValueOf(impl)

t := ai.constructor.Type()

if t.Kind() != reflect.Func {

return errors.New("non-function passed to RegisterAggregator")

}

if t.NumOut() != 1 && t.NumOut() != 2 {

return errors.New("SQLite aggregator constructors must return 1 or 2 values")

}

if t.NumOut() == 2 && !t.Out(1).Implements(reflect.TypeOf((*error)(nil)).Elem()) {

return errors.New("Second return value of SQLite function must be error")

}

if t.NumIn() != 0 {

return errors.New("SQLite aggregator constructors must not have arguments")

}

agg := t.Out(0)

switch agg.Kind() {

case reflect.Ptr, reflect.Interface:

default:

return errors.New("SQlite aggregator constructor must return a pointer object")

}

stepFn, found := agg.MethodByName("Step")

if !found {

return errors.New("SQlite aggregator doesn't have a Step() function")

}

step := stepFn.Type

if step.NumOut() != 0 && step.NumOut() != 1 {

return errors.New("SQlite aggregator Step() function must return 0 or 1 values")

}

if step.NumOut() == 1 && !step.Out(0).Implements(reflect.TypeOf((*error)(nil)).Elem()) {

return errors.New("type of SQlite aggregator Step() return value must be error")

}

stepNArgs := step.NumIn()

start := 0

if agg.Kind() == reflect.Ptr {

// Skip over the method receiver

stepNArgs--

start++

}

if step.IsVariadic() {

stepNArgs--

}

for i := start; i < start+stepNArgs; i++ {

conv, err := callbackArg(step.In(i))

if err != nil {

return err

}

ai.stepArgConverters = append(ai.stepArgConverters, conv)

}

if step.IsVariadic() {

conv, err := callbackArg(step.In(start + stepNArgs).Elem())

if err != nil {

return err

}

ai.stepVariadicConverter = conv

// Pass -1 to sqlite so that it allows any number of

// arguments. The call helper verifies that the minimum number

// of arguments is present for variadic functions.

stepNArgs = -1

}

doneFn, found := agg.MethodByName("Done")

if !found {

return errors.New("SQlite aggregator doesn't have a Done() function")

}

done := doneFn.Type

doneNArgs := done.NumIn()

if agg.Kind() == reflect.Ptr {

// Skip over the method receiver

doneNArgs--

}

if doneNArgs != 0 {

return errors.New("SQlite aggregator Done() function must have no arguments")

}

if done.NumOut() != 1 && done.NumOut() != 2 {

return errors.New("SQLite aggregator Done() function must return 1 or 2 values")

}

if done.NumOut() == 2 && !done.Out(1).Implements(reflect.TypeOf((*error)(nil)).Elem()) {

return errors.New("second return value of SQLite aggregator Done() function must be error")

}

conv, err := callbackRet(done.Out(0))

if err != nil {

return err

}

ai.doneRetConverter = conv

ai.active = make(map[int64]reflect.Value)

ai.next = 1

// ai must outlast the database connection, or we'll have dangling pointers.

c.aggregators = append(c.aggregators, &ai)

cname := C.CString(name)

defer C.free(unsafe.Pointer(cname))

opts := C.SQLITE_UTF8

if pure {

opts |= C.SQLITE_DETERMINISTIC

}

rv := sqlite3CreateFunction(c.db, cname, C.int(stepNArgs), C.int(opts), newHandle(c, &ai), nil, C.stepTrampoline, C.doneTrampoline)

if rv != C.SQLITE_OK {

return c.lastError()

}

return nil

}

// AutoCommit return which currently auto commit or not.

func (c *SQLiteConn) AutoCommit() bool {

c.mu.Lock()

defer c.mu.Unlock()

return int(C.sqlite3_get_autocommit(c.db)) != 0

}

func (c *SQLiteConn) lastError() error {

return lastError(c.db)

}

// Note: may be called with db == nil

func lastError(db *C.sqlite3) error {

rv := C.sqlite3_errcode(db) // returns SQLITE_NOMEM if db == nil

if rv == C.SQLITE_OK {

return nil

}

extrv := C.sqlite3_extended_errcode(db) // returns SQLITE_NOMEM if db == nil

errStr := C.GoString(C.sqlite3_errmsg(db)) // returns "out of memory" if db == nil

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

// sqlite3_system_errno is only meaningful if the error code was SQLITE_CANTOPEN,

// or it was SQLITE_IOERR and the extended code was not SQLITE_IOERR_NOMEM

var systemErrno syscall.Errno

if rv == C.SQLITE_CANTOPEN || (rv == C.SQLITE_IOERR && extrv != C.SQLITE_IOERR_NOMEM) {

systemErrno = syscall.Errno(C.sqlite3_system_errno(db))

}

return Error{

Code: ErrNo(rv),

ExtendedCode: ErrNoExtended(extrv),

SystemErrno: systemErrno,

err: errStr,

}

}

// Exec implements Execer.

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

list := make([]driver.NamedValue, len(args))

for i, v := range args {

list[i] = driver.NamedValue{

Ordinal: i + 1,

Value: v,

}

}

return c.exec(context.Background(), query, list)

}

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

start := 0

for {

s, err := c.prepare(ctx, query)

if err != nil {

return nil, err

}

var res driver.Result

if s.(*SQLiteStmt).s != nil {

stmtArgs := make([]driver.NamedValue, 0, len(args))

na := s.NumInput()

if len(args)-start < na {

s.Close()

return nil, fmt.Errorf("not enough args to execute query: want %d got %d", na, len(args))

}

// consume the number of arguments used in the current

// statement and append all named arguments not

// contained therein

if len(args[start:start+na]) > 0 {

stmtArgs = append(stmtArgs, args[start:start+na]...)

for i := range args {

if (i < start || i >= na) && args[i].Name != "" {

stmtArgs = append(stmtArgs, args[i])

}

}

for i := range stmtArgs {

stmtArgs[i].Ordinal = i + 1

}

}

res, err = s.(*SQLiteStmt).exec(ctx, stmtArgs)

if err != nil && err != driver.ErrSkip {

s.Close()

return nil, err

}

start += na

}

tail := s.(*SQLiteStmt).t

s.Close()

if tail == "" {

if res == nil {

// https://github.com/mattn/go-sqlite3/issues/963

res = &SQLiteResult{0, 0}

}

return res, nil

}

query = tail

}

}

// Query implements Queryer.

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

list := make([]driver.NamedValue, len(args))

for i, v := range args {

list[i] = driver.NamedValue{

Ordinal: i + 1,

Value: v,

}

}

return c.query(context.Background(), query, list)

}

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

start := 0

for {

stmtArgs := make([]driver.NamedValue, 0, len(args))

s, err := c.prepare(ctx, query)

if err != nil {

return nil, err

}

s.(*SQLiteStmt).cls = true

na := s.NumInput()

if len(args)-start < na {

s.Close()

return nil, fmt.Errorf("not enough args to execute query: want %d got %d", na, len(args)-start)

}

// consume the number of arguments used in the current

// statement and append all named arguments not contained

// therein

stmtArgs = append(stmtArgs, args[start:start+na]...)

for i := range args {

if (i < start || i >= na) && args[i].Name != "" {

stmtArgs = append(stmtArgs, args[i])

}

}

for i := range stmtArgs {

stmtArgs[i].Ordinal = i + 1

}

rows, err := s.(*SQLiteStmt).query(ctx, stmtArgs)

if err != nil && err != driver.ErrSkip {

s.Close()

return rows, err

}

start += na

tail := s.(*SQLiteStmt).t

if tail == "" {

return rows, nil

}

rows.Close()

s.Close()

query = tail

}

}

// Begin transaction.

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

return c.begin(context.Background())

}

func (c *SQLiteConn) begin(ctx context.Context) (driver.Tx, error) {

if _, err := c.exec(ctx, c.txlock, nil); err != nil {

return nil, err

}

return &SQLiteTx{c}, nil

}

// 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

//