gosqlite: replace uintptr handles with Go pointers

raggi · raggi · commit 0b47c1fc0b4d · 2026-01-06T12:31:54.000-08:00
Removed the uintptr indirection for sqlite3_stmt, replacing the uintptr with a plain Go pointer. Since 34bef2d was authored the toolchain has changed such that the indirection is no longer necessary to avoid allocations. Restoring regular pointers will enable regular tooling to function again and simplifies the code. ``` │ /tmp/uintptr-bench.txt │ /tmp/no-cstmt-bench.txt │ │ allocs/op │ allocs/op vs base │ WALHookAndExec-16 1.000 ± 0% 1.000 ± 0% ~ (p=1.000 n=10) ¹ Persist-16 11.00 ± 0% 11.00 ± 0% ~ (p=1.000 n=10) ¹ QueryRows100MixedTypes-16 107.0 ± 0% 107.0 ± 0% ~ (p=1.000 n=10) ¹ EmptyExec-16 1.000 ± 0% 1.000 ± 0% ~ (p=1.000 n=10) ¹ BeginTxNoop-16 13.00 ± 0% 13.00 ± 0% ~ (p=1.000 n=10) ¹ geomean 6.870 6.870 +0.00% ¹ all samples are equal ``` Updates tailscale/corp#9919
diff --git a/cgosqlite/cgosqlite.go b/cgosqlite/cgosqlite.go
@@ -68,31 +68,10 @@ type DB struct {
 	declTypes map[string]string
 }
 
-// cStmt is a wrapper around an sqlite3 *sqlite3_stmt. Except rather than
-// storing it as a pointer, it's stored as uintptr to avoid allocations due to
-// poor interactions between cgo's pointer checker and Go's escape analysis.
-//
-// The ptr method returns the value as a pointer, for call sites that haven't
-// yet been optimized or don't need the optimization. This lets us migrate
-// incrementally.
-//
-// See http://go/corp/9919.
-type cStmt struct {
-	v C.handle_sqlite3_stmt
-}
-
-// cStmtFromPtr returns a cStmt from a C pointer.
-func cStmtFromPtr(p *C.sqlite3_stmt) cStmt {
-	return cStmt{v: C.handle_sqlite3_stmt(uintptr(unsafe.Pointer(p)))}
-}
-
-func (h cStmt) int() C.handle_sqlite3_stmt { return h.v }
-func (h cStmt) ptr() *C.sqlite3_stmt       { return (*C.sqlite3_stmt)(unsafe.Pointer(uintptr(h.v))) }
-
 // Stmt implements sqliteh.Stmt.
 type Stmt struct {
 	db    *DB
-	stmt  cStmt
+	stmt  *C.sqlite3_stmt
 	start C.struct_timespec
 
 	// used as scratch space when calling into cgo
@@ -202,7 +181,7 @@ func (db *DB) Prepare(query string, prepFlags sqliteh.PrepareFlags) (stmt sqlite
 		return nil, "", err
 	}
 	remainingQuery = query[len(query)-int(C.strlen(csqlTail)):]
-	return &Stmt{db: db, stmt: cStmtFromPtr(cstmt)}, remainingQuery, nil
+	return &Stmt{db: db, stmt: cstmt}, remainingQuery, nil
 }
 
 func (db *DB) DisableFunction(name string, numArgs int) error {
@@ -212,45 +191,45 @@ func (db *DB) DisableFunction(name string, numArgs int) error {
 }
 
 func (stmt *Stmt) DBHandle() sqliteh.DB {
-	cdb := C.sqlite3_db_handle(stmt.stmt.ptr())
+	cdb := C.sqlite3_db_handle(stmt.stmt)
 	if cdb != nil {
 		return &DB{db: cdb}
 	}
 	return nil
 }
 
 func (stmt *Stmt) SQL() string {
-	return C.GoString(C.sqlite3_sql(stmt.stmt.ptr()))
+	return C.GoString(C.sqlite3_sql(stmt.stmt))
 }
 
 func (stmt *Stmt) ExpandedSQL() string {
 	// sqlite3_expanded_sql returns a string obtained by sqlite3_malloc, which
 	// must be freed after use.
-	cstr := C.sqlite3_expanded_sql(stmt.stmt.ptr())
+	cstr := C.sqlite3_expanded_sql(stmt.stmt)
 	defer C.sqlite3_free(unsafe.Pointer(cstr))
 	return C.GoString(cstr)
 }
 
 func (stmt *Stmt) Reset() error {
-	return errCode(C.sqlite3_reset(stmt.stmt.ptr()))
+	return errCode(C.sqlite3_reset(stmt.stmt))
 }
 
 func (stmt *Stmt) Finalize() error {
-	return errCode(C.sqlite3_finalize(stmt.stmt.ptr()))
+	return errCode(C.sqlite3_finalize(stmt.stmt))
 }
 
 func (stmt *Stmt) ClearBindings() error {
-	return errCode(C.sqlite3_clear_bindings(stmt.stmt.ptr()))
+	return errCode(C.sqlite3_clear_bindings(stmt.stmt))
 }
 
 func (stmt *Stmt) ResetAndClear() (time.Duration, error) {
 	if stmt.start != (C.struct_timespec{}) {
 		stmt.duration = 0
-		err := errCode(C.reset_and_clear(stmt.stmt.int(), &stmt.start, &stmt.duration))
+		err := errCode(C.reset_and_clear(stmt.stmt, &stmt.start, &stmt.duration))
 		return time.Duration(stmt.duration), err
 	}
-	if sp := stmt.stmt.int(); sp != 0 {
-		return 0, errCode(C.reset_and_clear(stmt.stmt.int(), nil, nil))
+	if stmt.stmt != nil {
+		return 0, errCode(C.reset_and_clear(stmt.stmt, nil, nil))
 	}
 	// The statement was never initialized. This can happen if, for example, the
 	// parser found only comments (so the statement was not empty, but did not
@@ -263,19 +242,19 @@ func (stmt *Stmt) StartTimer() {
 }
 
 func (stmt *Stmt) ColumnDatabaseName(col int) string {
-	return C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_database_name(stmt.stmt.ptr(), C.int(col)))))
+	return C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_database_name(stmt.stmt, C.int(col)))))
 }
 
 func (stmt *Stmt) ColumnTableName(col int) string {
-	return C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_table_name(stmt.stmt.ptr(), C.int(col)))))
+	return C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_table_name(stmt.stmt, C.int(col)))))
 }
 
 func (stmt *Stmt) Step(colType []sqliteh.ColumnType) (row bool, err error) {
 	var ptr *C.char
 	if len(colType) > 0 {
 		ptr = (*C.char)(unsafe.Pointer(&colType[0]))
 	}
-	res := C.ts_sqlite3_step(stmt.stmt.int(), ptr, C.int(len(colType)))
+	res := C.ts_sqlite3_step(stmt.stmt, ptr, C.int(len(colType)))
 	switch res {
 	case C.SQLITE_ROW:
 		return true, nil
@@ -288,7 +267,7 @@ func (stmt *Stmt) Step(colType []sqliteh.ColumnType) (row bool, err error) {
 
 func (stmt *Stmt) StepResult() (row bool, lastInsertRowID, changes int64, d time.Duration, err error) {
 	stmt.rowid, stmt.changes, stmt.duration = 0, 0, 0
-	res := C.step_result(stmt.stmt.int(), &stmt.rowid, &stmt.changes, &stmt.duration)
+	res := C.step_result(stmt.stmt, &stmt.rowid, &stmt.changes, &stmt.duration)
 	lastInsertRowID = int64(stmt.rowid)
 	changes = int64(stmt.changes)
 	d = time.Duration(stmt.duration)
@@ -304,51 +283,51 @@ func (stmt *Stmt) StepResult() (row bool, lastInsertRowID, changes int64, d time
 }
 
 func (stmt *Stmt) BindDouble(col int, val float64) error {
-	return errCode(C.ts_sqlite3_bind_double(stmt.stmt.int(), C.int(col), C.double(val)))
+	return errCode(C.sqlite3_bind_double(stmt.stmt, C.int(col), C.double(val)))
 }
 
 func (stmt *Stmt) BindInt64(col int, val int64) error {
-	return errCode(C.ts_sqlite3_bind_int64(stmt.stmt.int(), C.int(col), C.sqlite3_int64(val)))
+	return errCode(C.sqlite3_bind_int64(stmt.stmt, C.int(col), C.sqlite3_int64(val)))
 }
 
 func (stmt *Stmt) BindNull(col int) error {
-	return errCode(C.ts_sqlite3_bind_null(stmt.stmt.int(), C.int(col)))
+	return errCode(C.sqlite3_bind_null(stmt.stmt, C.int(col)))
 }
 
 func (stmt *Stmt) BindText64(col int, val string) error {
 	if len(val) == 0 {
-		return errCode(C.bind_text64_empty(stmt.stmt.int(), C.int(col)))
+		return errCode(C.bind_text64_empty(stmt.stmt, C.int(col)))
 	}
 	v := C.CString(val) // freed by sqlite
-	return errCode(C.bind_text64(stmt.stmt.int(), C.int(col), v, C.sqlite3_uint64(len(val))))
+	return errCode(C.bind_text64(stmt.stmt, C.int(col), v, C.sqlite3_uint64(len(val))))
 }
 
 func (stmt *Stmt) BindZeroBlob64(col int, n uint64) error {
-	return errCode(C.sqlite3_bind_zeroblob64(stmt.stmt.ptr(), C.int(col), C.sqlite3_uint64(n)))
+	return errCode(C.sqlite3_bind_zeroblob64(stmt.stmt, C.int(col), C.sqlite3_uint64(n)))
 }
 
 func (stmt *Stmt) BindBlob64(col int, val []byte) error {
 	var str *C.char
 	if len(val) > 0 {
 		str = (*C.char)(unsafe.Pointer(&val[0]))
 	}
-	return errCode(C.bind_blob64(stmt.stmt.int(), C.int(col), str, C.sqlite3_uint64(len(val))))
+	return errCode(C.bind_blob64(stmt.stmt, C.int(col), str, C.sqlite3_uint64(len(val))))
 }
 
 func (stmt *Stmt) BindParameterCount() int {
-	return int(C.sqlite3_bind_parameter_count(stmt.stmt.ptr()))
+	return int(C.sqlite3_bind_parameter_count(stmt.stmt))
 }
 
 func (stmt *Stmt) BindParameterName(col int) string {
-	cstr := C.sqlite3_bind_parameter_name(stmt.stmt.ptr(), C.int(col))
+	cstr := C.sqlite3_bind_parameter_name(stmt.stmt, C.int(col))
 	if cstr == nil {
 		return ""
 	}
 	return C.GoString(cstr)
 }
 
 func (stmt *Stmt) BindParameterIndex(name string) int {
-	return int(C.bind_parameter_index(stmt.stmt.int(), name))
+	return int(C.bind_parameter_index(stmt.stmt, name))
 }
 
 func (stmt *Stmt) BindParameterIndexSearch(name string) int {
@@ -363,45 +342,45 @@ func (stmt *Stmt) BindParameterIndexSearch(name string) int {
 }
 
 func (stmt *Stmt) ColumnCount() int {
-	return int(C.sqlite3_column_count(stmt.stmt.ptr()))
+	return int(C.sqlite3_column_count(stmt.stmt))
 }
 
 func (stmt *Stmt) ColumnName(col int) string {
-	return C.GoString(C.sqlite3_column_name(stmt.stmt.ptr(), C.int(col)))
+	return C.GoString(C.sqlite3_column_name(stmt.stmt, C.int(col)))
 }
 
 func (stmt *Stmt) ColumnText(col int) string {
-	str := (*C.char)(unsafe.Pointer(C.ts_sqlite3_column_text(stmt.stmt.int(), C.int(col))))
-	n := C.ts_sqlite3_column_bytes(stmt.stmt.int(), C.int(col))
+	str := (*C.char)(unsafe.Pointer(C.ts_sqlite3_column_text(stmt.stmt, C.int(col))))
+	n := C.ts_sqlite3_column_bytes(stmt.stmt, C.int(col))
 	if str == nil || n == 0 {
 		return ""
 	}
 	return C.GoStringN(str, n)
 }
 
 func (stmt *Stmt) ColumnBlob(col int) []byte {
-	res := C.ts_sqlite3_column_blob(stmt.stmt.int(), C.int(col))
+	res := C.ts_sqlite3_column_blob(stmt.stmt, C.int(col))
 	if res == nil {
 		return nil
 	}
-	n := int(C.ts_sqlite3_column_bytes(stmt.stmt.int(), C.int(col)))
+	n := int(C.ts_sqlite3_column_bytes(stmt.stmt, C.int(col)))
 	return unsafe.Slice((*byte)(unsafe.Pointer(res)), n)
 }
 
 func (stmt *Stmt) ColumnDouble(col int) float64 {
-	return float64(C.ts_sqlite3_column_double(stmt.stmt.int(), C.int(col)))
+	return float64(C.ts_sqlite3_column_double(stmt.stmt, C.int(col)))
 }
 
 func (stmt *Stmt) ColumnInt64(col int) int64 {
-	return int64(C.ts_sqlite3_column_int64(stmt.stmt.int(), C.int(col)))
+	return int64(C.ts_sqlite3_column_int64(stmt.stmt, C.int(col)))
 }
 
 func (stmt *Stmt) ColumnType(col int) sqliteh.ColumnType {
-	return sqliteh.ColumnType(C.ts_sqlite3_column_type(stmt.stmt.int(), C.int(col)))
+	return sqliteh.ColumnType(C.ts_sqlite3_column_type(stmt.stmt, C.int(col)))
 }
 
 func (stmt *Stmt) ColumnDeclType(col int) string {
-	cstr := C.sqlite3_column_decltype(stmt.stmt.ptr(), C.int(col))
+	cstr := C.sqlite3_column_decltype(stmt.stmt, C.int(col))
 	if cstr == nil {
 		return ""
 	}
diff --git a/cgosqlite/cgosqlite.h b/cgosqlite/cgosqlite.h
@@ -5,41 +5,24 @@
 #include <string.h>
 #include <time.h>
 
-// uintptr versions of sqlite3 pointer types, to avoid allocations
-// in cgo code. (go/corp/9919)
-typedef uintptr_t handle_sqlite3_stmt; // a *sqlite3_stmt
-typedef uintptr_t handle_sqlite3; // a *sqlite3 (DB conn)
-
 // Helper methods to deal with int <-> pointer pain.
 
-static int bind_text64(handle_sqlite3_stmt stmt, int col, const char* str, sqlite3_uint64 len) {
-	return sqlite3_bind_text64((sqlite3_stmt*)(stmt), col, str, len, free, SQLITE_UTF8);
-}
-
-static int bind_text64_empty(handle_sqlite3_stmt stmt, int col) {
-	return sqlite3_bind_text64((sqlite3_stmt*)(stmt), col, "", 0, SQLITE_STATIC, SQLITE_UTF8);
-}
-
-static int bind_blob64(handle_sqlite3_stmt stmt, int col, char* str, sqlite3_uint64 n) {
-	return sqlite3_bind_blob64((sqlite3_stmt*)(stmt), col, str, n, SQLITE_TRANSIENT);
-}
-
-static int ts_sqlite3_bind_double(handle_sqlite3_stmt stmt, int col, double v) {
-	return sqlite3_bind_double((sqlite3_stmt*)(stmt), col, v);
+static int bind_text64(sqlite3_stmt* stmt, int col, const char* str, sqlite3_uint64 len) {
+	return sqlite3_bind_text64(stmt, col, str, len, free, SQLITE_UTF8);
 }
 
-static int ts_sqlite3_bind_int64(handle_sqlite3_stmt stmt, int col, sqlite3_int64 v) {
-	return sqlite3_bind_int64((sqlite3_stmt*)(stmt), col, v);
+static int bind_text64_empty(sqlite3_stmt* stmt, int col) {
+	return sqlite3_bind_text64(stmt, col, "", 0, SQLITE_STATIC, SQLITE_UTF8);
 }
 
-static int ts_sqlite3_bind_null(handle_sqlite3_stmt stmt, int col) {
-	return sqlite3_bind_null((sqlite3_stmt*)(stmt), col);
+static int bind_blob64(sqlite3_stmt* stmt, int col, char* str, sqlite3_uint64 n) {
+	return sqlite3_bind_blob64(stmt, col, str, n, SQLITE_TRANSIENT);
 }
 
 // We only need the Go string's memory for the duration of the call,
 // and the GC pins it for us if we pass the gostring_t to C, so we
 // do the conversion here instead of with C.CString.
-static int bind_parameter_index(handle_sqlite3_stmt stmt, _GoString_ s) {
+static int bind_parameter_index(sqlite3_stmt* stmt, _GoString_ s) {
 	size_t n = _GoStringLen(s);
 	const char *p = (const char *)_GoStringPtr(s);
 
@@ -49,7 +32,7 @@ static int bind_parameter_index(handle_sqlite3_stmt stmt, _GoString_ s) {
 		return 0;
 	}
 	memmove(zName, p, n);
-	return sqlite3_bind_parameter_index((sqlite3_stmt*)(stmt), zName);
+	return sqlite3_bind_parameter_index(stmt, zName);
 }
 
 static void monotonic_clock_gettime(struct timespec* t) {
@@ -65,8 +48,7 @@ static int64_t ns_since(const struct timespec t1)
 }
 
 // step_result combines several cgo calls to save overhead.
-static int step_result(handle_sqlite3_stmt stmth, sqlite3_int64* rowid, sqlite3_int64* changes, int64_t* duration_ns) {
-	sqlite3_stmt* stmt = (sqlite3_stmt*)(stmth);
+static int step_result(sqlite3_stmt* stmt, sqlite3_int64* rowid, sqlite3_int64* changes, int64_t* duration_ns) {
 	struct timespec t1;
 	if (duration_ns) {
 		monotonic_clock_gettime(&t1);
@@ -84,8 +66,7 @@ static int step_result(handle_sqlite3_stmt stmth, sqlite3_int64* rowid, sqlite3_
 }
 
 // reset_and_clear combines two cgo calls to save overhead.
-static int reset_and_clear(handle_sqlite3_stmt stmth, struct timespec* start, int64_t* duration_ns) {
-	sqlite3_stmt* stmt = (sqlite3_stmt*)(stmth);
+static int reset_and_clear(sqlite3_stmt* stmt, struct timespec* start, int64_t* duration_ns) {
 	int ret = sqlite3_reset(stmt);
 	int ret2 = sqlite3_clear_bindings(stmt);
 	if (duration_ns) {
@@ -111,8 +92,7 @@ static void ts_sqlite3_wal_hook_go(sqlite3* db) {
 	sqlite3_wal_hook(db, wal_callback_into_go, 0);
 }
 
-static int ts_sqlite3_step(handle_sqlite3_stmt stmth, char* outType , int outTypeLen) {
-	sqlite3_stmt* stmt = (sqlite3_stmt*)(stmth);
+static int ts_sqlite3_step(sqlite3_stmt* stmt, char* outType , int outTypeLen) {
 	int res = sqlite3_step(stmt);
 	if (res == SQLITE_ROW && outTypeLen > 0) {
 		int cols = sqlite3_column_count(stmt);
@@ -123,28 +103,28 @@ static int ts_sqlite3_step(handle_sqlite3_stmt stmth, char* outType , int outTyp
 	return res;
 }
 
-static const unsigned char *ts_sqlite3_column_text(handle_sqlite3_stmt stmt, int iCol) {
-	return sqlite3_column_text((sqlite3_stmt*)(stmt), iCol);
+static const unsigned char *ts_sqlite3_column_text(sqlite3_stmt* stmt, int iCol) {
+	return sqlite3_column_text(stmt, iCol);
 }
 
-static const unsigned char *ts_sqlite3_column_blob(handle_sqlite3_stmt stmt, int iCol) {
-	return sqlite3_column_blob((sqlite3_stmt*)(stmt), iCol);
+static const unsigned char *ts_sqlite3_column_blob(sqlite3_stmt* stmt, int iCol) {
+	return sqlite3_column_blob(stmt, iCol);
 }
 
-static int ts_sqlite3_column_type(handle_sqlite3_stmt stmt, int iCol) {
-	return sqlite3_column_type((sqlite3_stmt*)(stmt), iCol);
+static int ts_sqlite3_column_type(sqlite3_stmt* stmt, int iCol) {
+	return sqlite3_column_type(stmt, iCol);
 }
 
-static int ts_sqlite3_column_bytes(handle_sqlite3_stmt stmt, int iCol) {
-	return sqlite3_column_bytes((sqlite3_stmt*)(stmt), iCol);
+static int ts_sqlite3_column_bytes(sqlite3_stmt* stmt, int iCol) {
+	return sqlite3_column_bytes(stmt, iCol);
 }
 
-static double ts_sqlite3_column_double(handle_sqlite3_stmt stmt, int iCol) {
-	return sqlite3_column_double((sqlite3_stmt*)(stmt), iCol);
+static double ts_sqlite3_column_double(sqlite3_stmt* stmt, int iCol) {
+	return sqlite3_column_double(stmt, iCol);
 }
 
-static sqlite3_int64 ts_sqlite3_column_int64(handle_sqlite3_stmt stmt, int iCol) {
-	return sqlite3_column_int64((sqlite3_stmt*)(stmt), iCol);
+static sqlite3_int64 ts_sqlite3_column_int64(sqlite3_stmt* stmt, int iCol) {
+	return sqlite3_column_int64(stmt, iCol);
 }
 
 static int ts_sqlite3_disable_function(sqlite3 *db, const char *zFunctionName, int nArg) {

Original file line number	Diff line number	Diff line change
`@@ -68,31 +68,10 @@ type DB struct {`
`68`	`68`	`declTypes map[string]string`
`69`	`69`	`}`
`70`	`70`
`71`		`-// cStmt is a wrapper around an sqlite3 *sqlite3_stmt. Except rather than`
`72`		`-// storing it as a pointer, it's stored as uintptr to avoid allocations due to`
`73`		`-// poor interactions between cgo's pointer checker and Go's escape analysis.`
`74`		`-//`
`75`		`-// The ptr method returns the value as a pointer, for call sites that haven't`
`76`		`-// yet been optimized or don't need the optimization. This lets us migrate`
`77`		`-// incrementally.`
`78`		`-//`
`79`		`-// See http://go/corp/9919.`
`80`		`-type cStmt struct {`
`81`		`- v C.handle_sqlite3_stmt`
`82`		`-}`
`83`		`-`
`84`		`-// cStmtFromPtr returns a cStmt from a C pointer.`
`85`		`-func cStmtFromPtr(p *C.sqlite3_stmt) cStmt {`
`86`		`- return cStmt{v: C.handle_sqlite3_stmt(uintptr(unsafe.Pointer(p)))}`
`87`		`-}`
`88`		`-`
`89`		`-func (h cStmt) int() C.handle_sqlite3_stmt { return h.v }`
`90`		`-func (h cStmt) ptr() C.sqlite3_stmt { return (C.sqlite3_stmt)(unsafe.Pointer(uintptr(h.v))) }`
`91`		`-`
`92`	`71`	`// Stmt implements sqliteh.Stmt.`
`93`	`72`	`type Stmt struct {`
`94`	`73`	`db *DB`
`95`		`- stmt cStmt`
	`74`	`+ stmt *C.sqlite3_stmt`
`96`	`75`	`start C.struct_timespec`
`97`	`76`
`98`	`77`	`// used as scratch space when calling into cgo`
`@@ -202,7 +181,7 @@ func (db *DB) Prepare(query string, prepFlags sqliteh.PrepareFlags) (stmt sqlite`
`202`	`181`	`return nil, "", err`
`203`	`182`	`}`
`204`	`183`	`remainingQuery = query[len(query)-int(C.strlen(csqlTail)):]`
`205`		`- return &Stmt{db: db, stmt: cStmtFromPtr(cstmt)}, remainingQuery, nil`
	`184`	`+ return &Stmt{db: db, stmt: cstmt}, remainingQuery, nil`
`206`	`185`	`}`
`207`	`186`
`208`	`187`	`func (db *DB) DisableFunction(name string, numArgs int) error {`
`@@ -212,45 +191,45 @@ func (db *DB) DisableFunction(name string, numArgs int) error {`
`212`	`191`	`}`
`213`	`192`
`214`	`193`	`func (stmt *Stmt) DBHandle() sqliteh.DB {`
`215`		`- cdb := C.sqlite3_db_handle(stmt.stmt.ptr())`
	`194`	`+ cdb := C.sqlite3_db_handle(stmt.stmt)`
`216`	`195`	`if cdb != nil {`
`217`	`196`	`return &DB{db: cdb}`
`218`	`197`	`}`
`219`	`198`	`return nil`
`220`	`199`	`}`
`221`	`200`
`222`	`201`	`func (stmt *Stmt) SQL() string {`
`223`		`- return C.GoString(C.sqlite3_sql(stmt.stmt.ptr()))`
	`202`	`+ return C.GoString(C.sqlite3_sql(stmt.stmt))`
`224`	`203`	`}`
`225`	`204`
`226`	`205`	`func (stmt *Stmt) ExpandedSQL() string {`
`227`	`206`	`// sqlite3_expanded_sql returns a string obtained by sqlite3_malloc, which`
`228`	`207`	`// must be freed after use.`
`229`		`- cstr := C.sqlite3_expanded_sql(stmt.stmt.ptr())`
	`208`	`+ cstr := C.sqlite3_expanded_sql(stmt.stmt)`
`230`	`209`	`defer C.sqlite3_free(unsafe.Pointer(cstr))`
`231`	`210`	`return C.GoString(cstr)`
`232`	`211`	`}`
`233`	`212`
`234`	`213`	`func (stmt *Stmt) Reset() error {`
`235`		`- return errCode(C.sqlite3_reset(stmt.stmt.ptr()))`
	`214`	`+ return errCode(C.sqlite3_reset(stmt.stmt))`
`236`	`215`	`}`
`237`	`216`
`238`	`217`	`func (stmt *Stmt) Finalize() error {`
`239`		`- return errCode(C.sqlite3_finalize(stmt.stmt.ptr()))`
	`218`	`+ return errCode(C.sqlite3_finalize(stmt.stmt))`
`240`	`219`	`}`
`241`	`220`
`242`	`221`	`func (stmt *Stmt) ClearBindings() error {`
`243`		`- return errCode(C.sqlite3_clear_bindings(stmt.stmt.ptr()))`
	`222`	`+ return errCode(C.sqlite3_clear_bindings(stmt.stmt))`
`244`	`223`	`}`
`245`	`224`
`246`	`225`	`func (stmt *Stmt) ResetAndClear() (time.Duration, error) {`
`247`	`226`	`if stmt.start != (C.struct_timespec{}) {`
`248`	`227`	`stmt.duration = 0`
`249`		`- err := errCode(C.reset_and_clear(stmt.stmt.int(), &stmt.start, &stmt.duration))`
	`228`	`+ err := errCode(C.reset_and_clear(stmt.stmt, &stmt.start, &stmt.duration))`
`250`	`229`	`return time.Duration(stmt.duration), err`
`251`	`230`	`}`
`252`		`- if sp := stmt.stmt.int(); sp != 0 {`
`253`		`- return 0, errCode(C.reset_and_clear(stmt.stmt.int(), nil, nil))`
	`231`	`+ if stmt.stmt != nil {`
	`232`	`+ return 0, errCode(C.reset_and_clear(stmt.stmt, nil, nil))`
`254`	`233`	`}`
`255`	`234`	`// The statement was never initialized. This can happen if, for example, the`
`256`	`235`	`// parser found only comments (so the statement was not empty, but did not`
`@@ -263,19 +242,19 @@ func (stmt *Stmt) StartTimer() {`
`263`	`242`	`}`
`264`	`243`
`265`	`244`	`func (stmt *Stmt) ColumnDatabaseName(col int) string {`
`266`		`- return C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_database_name(stmt.stmt.ptr(), C.int(col)))))`
	`245`	`+ return C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_database_name(stmt.stmt, C.int(col)))))`
`267`	`246`	`}`
`268`	`247`
`269`	`248`	`func (stmt *Stmt) ColumnTableName(col int) string {`
`270`		`- return C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_table_name(stmt.stmt.ptr(), C.int(col)))))`
	`249`	`+ return C.GoString((*C.char)(unsafe.Pointer(C.sqlite3_column_table_name(stmt.stmt, C.int(col)))))`
`271`	`250`	`}`
`272`	`251`
`273`	`252`	`func (stmt *Stmt) Step(colType []sqliteh.ColumnType) (row bool, err error) {`
`274`	`253`	`var ptr *C.char`
`275`	`254`	`if len(colType) > 0 {`
`276`	`255`	`ptr = (*C.char)(unsafe.Pointer(&colType[0]))`
`277`	`256`	`}`
`278`		`- res := C.ts_sqlite3_step(stmt.stmt.int(), ptr, C.int(len(colType)))`
	`257`	`+ res := C.ts_sqlite3_step(stmt.stmt, ptr, C.int(len(colType)))`
`279`	`258`	`switch res {`
`280`	`259`	`case C.SQLITE_ROW:`
`281`	`260`	`return true, nil`
`@@ -288,7 +267,7 @@ func (stmt *Stmt) Step(colType []sqliteh.ColumnType) (row bool, err error) {`
`288`	`267`
`289`	`268`	`func (stmt *Stmt) StepResult() (row bool, lastInsertRowID, changes int64, d time.Duration, err error) {`
`290`	`269`	`stmt.rowid, stmt.changes, stmt.duration = 0, 0, 0`
`291`		`- res := C.step_result(stmt.stmt.int(), &stmt.rowid, &stmt.changes, &stmt.duration)`
	`270`	`+ res := C.step_result(stmt.stmt, &stmt.rowid, &stmt.changes, &stmt.duration)`
`292`	`271`	`lastInsertRowID = int64(stmt.rowid)`
`293`	`272`	`changes = int64(stmt.changes)`
`294`	`273`	`d = time.Duration(stmt.duration)`
`@@ -304,51 +283,51 @@ func (stmt *Stmt) StepResult() (row bool, lastInsertRowID, changes int64, d time`
`304`	`283`	`}`
`305`	`284`
`306`	`285`	`func (stmt *Stmt) BindDouble(col int, val float64) error {`
`307`		`- return errCode(C.ts_sqlite3_bind_double(stmt.stmt.int(), C.int(col), C.double(val)))`
	`286`	`+ return errCode(C.sqlite3_bind_double(stmt.stmt, C.int(col), C.double(val)))`
`308`	`287`	`}`
`309`	`288`
`310`	`289`	`func (stmt *Stmt) BindInt64(col int, val int64) error {`
`311`		`- return errCode(C.ts_sqlite3_bind_int64(stmt.stmt.int(), C.int(col), C.sqlite3_int64(val)))`
	`290`	`+ return errCode(C.sqlite3_bind_int64(stmt.stmt, C.int(col), C.sqlite3_int64(val)))`
`312`	`291`	`}`
`313`	`292`
`314`	`293`	`func (stmt *Stmt) BindNull(col int) error {`
`315`		`- return errCode(C.ts_sqlite3_bind_null(stmt.stmt.int(), C.int(col)))`
	`294`	`+ return errCode(C.sqlite3_bind_null(stmt.stmt, C.int(col)))`
`316`	`295`	`}`
`317`	`296`
`318`	`297`	`func (stmt *Stmt) BindText64(col int, val string) error {`
`319`	`298`	`if len(val) == 0 {`
`320`		`- return errCode(C.bind_text64_empty(stmt.stmt.int(), C.int(col)))`
	`299`	`+ return errCode(C.bind_text64_empty(stmt.stmt, C.int(col)))`
`321`	`300`	`}`
`322`	`301`	`v := C.CString(val) // freed by sqlite`
`323`		`- return errCode(C.bind_text64(stmt.stmt.int(), C.int(col), v, C.sqlite3_uint64(len(val))))`
	`302`	`+ return errCode(C.bind_text64(stmt.stmt, C.int(col), v, C.sqlite3_uint64(len(val))))`
`324`	`303`	`}`
`325`	`304`
`326`	`305`	`func (stmt *Stmt) BindZeroBlob64(col int, n uint64) error {`
`327`		`- return errCode(C.sqlite3_bind_zeroblob64(stmt.stmt.ptr(), C.int(col), C.sqlite3_uint64(n)))`
	`306`	`+ return errCode(C.sqlite3_bind_zeroblob64(stmt.stmt, C.int(col), C.sqlite3_uint64(n)))`
`328`	`307`	`}`
`329`	`308`
`330`	`309`	`func (stmt *Stmt) BindBlob64(col int, val []byte) error {`
`331`	`310`	`var str *C.char`
`332`	`311`	`if len(val) > 0 {`
`333`	`312`	`str = (*C.char)(unsafe.Pointer(&val[0]))`
`334`	`313`	`}`
`335`		`- return errCode(C.bind_blob64(stmt.stmt.int(), C.int(col), str, C.sqlite3_uint64(len(val))))`
	`314`	`+ return errCode(C.bind_blob64(stmt.stmt, C.int(col), str, C.sqlite3_uint64(len(val))))`
`336`	`315`	`}`
`337`	`316`
`338`	`317`	`func (stmt *Stmt) BindParameterCount() int {`
`339`		`- return int(C.sqlite3_bind_parameter_count(stmt.stmt.ptr()))`
	`318`	`+ return int(C.sqlite3_bind_parameter_count(stmt.stmt))`
`340`	`319`	`}`
`341`	`320`
`342`	`321`	`func (stmt *Stmt) BindParameterName(col int) string {`
`343`		`- cstr := C.sqlite3_bind_parameter_name(stmt.stmt.ptr(), C.int(col))`
	`322`	`+ cstr := C.sqlite3_bind_parameter_name(stmt.stmt, C.int(col))`
`344`	`323`	`if cstr == nil {`
`345`	`324`	`return ""`
`346`	`325`	`}`
`347`	`326`	`return C.GoString(cstr)`
`348`	`327`	`}`
`349`	`328`
`350`	`329`	`func (stmt *Stmt) BindParameterIndex(name string) int {`
`351`		`- return int(C.bind_parameter_index(stmt.stmt.int(), name))`
	`330`	`+ return int(C.bind_parameter_index(stmt.stmt, name))`
`352`	`331`	`}`
`353`	`332`
`354`	`333`	`func (stmt *Stmt) BindParameterIndexSearch(name string) int {`
`@@ -363,45 +342,45 @@ func (stmt *Stmt) BindParameterIndexSearch(name string) int {`
`363`	`342`	`}`
`364`	`343`
`365`	`344`	`func (stmt *Stmt) ColumnCount() int {`
`366`		`- return int(C.sqlite3_column_count(stmt.stmt.ptr()))`
	`345`	`+ return int(C.sqlite3_column_count(stmt.stmt))`
`367`	`346`	`}`
`368`	`347`
`369`	`348`	`func (stmt *Stmt) ColumnName(col int) string {`
`370`		`- return C.GoString(C.sqlite3_column_name(stmt.stmt.ptr(), C.int(col)))`
	`349`	`+ return C.GoString(C.sqlite3_column_name(stmt.stmt, C.int(col)))`
`371`	`350`	`}`
`372`	`351`
`373`	`352`	`func (stmt *Stmt) ColumnText(col int) string {`
`374`		`- str := (*C.char)(unsafe.Pointer(C.ts_sqlite3_column_text(stmt.stmt.int(), C.int(col))))`
`375`		`- n := C.ts_sqlite3_column_bytes(stmt.stmt.int(), C.int(col))`
	`353`	`+ str := (*C.char)(unsafe.Pointer(C.ts_sqlite3_column_text(stmt.stmt, C.int(col))))`
	`354`	`+ n := C.ts_sqlite3_column_bytes(stmt.stmt, C.int(col))`
`376`	`355`	`if str == nil \|\| n == 0 {`
`377`	`356`	`return ""`
`378`	`357`	`}`
`379`	`358`	`return C.GoStringN(str, n)`
`380`	`359`	`}`
`381`	`360`
`382`	`361`	`func (stmt *Stmt) ColumnBlob(col int) []byte {`
`383`		`- res := C.ts_sqlite3_column_blob(stmt.stmt.int(), C.int(col))`
	`362`	`+ res := C.ts_sqlite3_column_blob(stmt.stmt, C.int(col))`
`384`	`363`	`if res == nil {`
`385`	`364`	`return nil`
`386`	`365`	`}`
`387`		`- n := int(C.ts_sqlite3_column_bytes(stmt.stmt.int(), C.int(col)))`
	`366`	`+ n := int(C.ts_sqlite3_column_bytes(stmt.stmt, C.int(col)))`
`388`	`367`	`return unsafe.Slice((*byte)(unsafe.Pointer(res)), n)`
`389`	`368`	`}`
`390`	`369`
`391`	`370`	`func (stmt *Stmt) ColumnDouble(col int) float64 {`
`392`		`- return float64(C.ts_sqlite3_column_double(stmt.stmt.int(), C.int(col)))`
	`371`	`+ return float64(C.ts_sqlite3_column_double(stmt.stmt, C.int(col)))`
`393`	`372`	`}`
`394`	`373`
`395`	`374`	`func (stmt *Stmt) ColumnInt64(col int) int64 {`
`396`		`- return int64(C.ts_sqlite3_column_int64(stmt.stmt.int(), C.int(col)))`
	`375`	`+ return int64(C.ts_sqlite3_column_int64(stmt.stmt, C.int(col)))`
`397`	`376`	`}`
`398`	`377`
`399`	`378`	`func (stmt *Stmt) ColumnType(col int) sqliteh.ColumnType {`
`400`		`- return sqliteh.ColumnType(C.ts_sqlite3_column_type(stmt.stmt.int(), C.int(col)))`
	`379`	`+ return sqliteh.ColumnType(C.ts_sqlite3_column_type(stmt.stmt, C.int(col)))`
`401`	`380`	`}`
`402`	`381`
`403`	`382`	`func (stmt *Stmt) ColumnDeclType(col int) string {`
`404`		`- cstr := C.sqlite3_column_decltype(stmt.stmt.ptr(), C.int(col))`
	`383`	`+ cstr := C.sqlite3_column_decltype(stmt.stmt, C.int(col))`
`405`	`384`	`if cstr == nil {`
`406`	`385`	`return ""`
`407`	`386`	`}`