sqlite.go

//go:build darwin && arm64 && go1.25

package sqlite

import (
	"runtime"
	"unsafe"
)

const (
	OK   int32 = 0
	ROW  int32 = 100
	DONE int32 = 101
)

const sqliteTransient = ^uintptr(0)

func cString(pinner *runtime.Pinner, value string) unsafe.Pointer {
	buffer := make([]byte, len(value)+1)
	copy(buffer, value)
	pinner.Pin(&buffer[0])
	return unsafe.Pointer(&buffer[0])
}

func pinned[T any](pinner *runtime.Pinner, value *T) unsafe.Pointer {
	pinner.Pin(value)
	return unsafe.Pointer(value)
}

func goString(value *byte) string {
	if value == nil {
		return ""
	}
	length := 0
	for *(*byte)(unsafe.Add(unsafe.Pointer(value), length)) != 0 {
		length++
	}
	result := make([]byte, length)
	for i := range result {
		result[i] = *(*byte)(unsafe.Add(unsafe.Pointer(value), i))
	}
	return string(result)
}

// Initialize initializes SQLite's process-global state. It must be called
// before Open because the c2go build disables SQLite's automatic initializer.
func Initialize() int32 { return Sqlite3Initialize() }

// Shutdown releases SQLite's process-global state after all handles are closed.
func Shutdown() int32 { return Sqlite3Shutdown() }

// Open opens or creates a database and returns its opaque SQLite handle.
func Open(path string) (unsafe.Pointer, int32) {
	var pinner runtime.Pinner
	defer pinner.Unpin()
	var database unsafe.Pointer
	rc := Sqlite3Open(cString(&pinner, path), pinned(&pinner, &database))
	return database, rc
}

// Close closes a database connection.
func Close(database unsafe.Pointer) int32 { return Sqlite3Close(database) }

// CloseV2 marks a database connection for deferred close.
func CloseV2(database unsafe.Pointer) int32 { return Sqlite3CloseV2(database) }

// Exec executes one or more SQL statements without returning rows.
func Exec(database unsafe.Pointer, query string) int32 {
	var pinner runtime.Pinner
	defer pinner.Unpin()
	return Sqlite3Exec(database, cString(&pinner, query), 0, nil, nil)
}

// Prepare compiles the first SQL statement in query.
func Prepare(database unsafe.Pointer, query string) (unsafe.Pointer, int32) {
	var pinner runtime.Pinner
	defer pinner.Unpin()
	var statement unsafe.Pointer
	rc := Sqlite3PrepareV2(
		database,
		cString(&pinner, query),
		-1,
		pinned(&pinner, &statement),
		nil,
	)
	return statement, rc
}

// Step advances a prepared statement and returns an SQLite result code.
func Step(statement unsafe.Pointer) int32 { return Sqlite3Step(statement) }

// Reset resets a prepared statement while retaining its bindings.
func Reset(statement unsafe.Pointer) int32 { return Sqlite3Reset(statement) }

// Finalize destroys a prepared statement.
func Finalize(statement unsafe.Pointer) int32 { return Sqlite3Finalize(statement) }

// BindText binds a Go string at SQLite's one-based parameter index. SQLite
// copies the bytes before this function returns.
func BindText(statement unsafe.Pointer, index int32, value string) int32 {
	var pinner runtime.Pinner
	defer pinner.Unpin()
	return Sqlite3BindText(
		statement,
		index,
		cString(&pinner, value),
		int32(len(value)),
		sqliteTransient,
	)
}

// BindInt binds a 32-bit integer at SQLite's one-based parameter index.
func BindInt(statement unsafe.Pointer, index, value int32) int32 {
	return Sqlite3BindInt(statement, index, value)
}

// BindInt64 binds a 64-bit integer at SQLite's one-based parameter index.
func BindInt64(statement unsafe.Pointer, index int32, value int64) int32 {
	return Sqlite3BindInt64(statement, index, value)
}

// BindDouble binds a floating-point value at SQLite's one-based parameter index.
func BindDouble(statement unsafe.Pointer, index int32, value float64) int32 {
	return Sqlite3BindDouble(statement, index, value)
}

// BindNull binds SQL NULL at SQLite's one-based parameter index.
func BindNull(statement unsafe.Pointer, index int32) int32 {
	return Sqlite3BindNull(statement, index)
}

// ColumnCount returns the number of columns in the current result set.
func ColumnCount(statement unsafe.Pointer) int32 {
	return Sqlite3ColumnCount(statement)
}

// ColumnText copies a text column from the current row into a Go string.
func ColumnText(statement unsafe.Pointer, column int32) string {
	return goString(Sqlite3ColumnText(statement, column))
}

// ColumnInt returns a column converted to a 32-bit integer.
func ColumnInt(statement unsafe.Pointer, column int32) int32 {
	return Sqlite3ColumnInt(statement, column)
}

// ColumnInt64 returns a column converted to a 64-bit integer.
func ColumnInt64(statement unsafe.Pointer, column int32) int64 {
	return Sqlite3ColumnInt64(statement, column)
}

// ColumnDouble returns a column converted to a floating-point value.
func ColumnDouble(statement unsafe.Pointer, column int32) float64 {
	return Sqlite3ColumnDouble(statement, column)
}

// ErrMsg copies the latest connection error message into a Go string.
func ErrMsg(database unsafe.Pointer) string {
	if database == nil {
		return ""
	}
	return goString(Sqlite3Errmsg(database))
}

// ExtendedErrCode returns the latest extended result code for a connection.
func ExtendedErrCode(database unsafe.Pointer) int32 {
	return Sqlite3ExtendedErrcode(database)
}

// LibVersion returns the SQLite version string.
func LibVersion() string { return goString(Sqlite3Libversion()) }

// LibVersionNumber returns SQLite's numeric version.
func LibVersionNumber() int32 { return Sqlite3LibversionNumber() }

// SourceID returns the upstream source identifier used by this build.
func SourceID() string { return goString(Sqlite3Sourceid()) }