typenative 0.1.2 → 0.2.0

package/govendor/github.com/ncruces/go-sqlite3/error.go

@@ -0,0 +1,182 @@
+package sqlite3
+
+import (
+	"errors"
+	"strings"
+
+	"github.com/ncruces/go-sqlite3/internal/sqlite3_wrap"
+)
+
+// Error wraps an SQLite Error Code.
+//
+// https://sqlite.org/c3ref/errcode.html
+type Error struct {
+	sys  error
+	msg  string
+	sql  string
+	code res_t
+}
+
+// Code returns the primary error code for this error.
+//
+// https://sqlite.org/rescode.html
+func (e *Error) Code() ErrorCode {
+	return ErrorCode(e.code)
+}
+
+// ExtendedCode returns the extended error code for this error.
+//
+// https://sqlite.org/rescode.html
+func (e *Error) ExtendedCode() ExtendedErrorCode {
+	return xErrorCode(e.code)
+}
+
+// Error implements the error interface.
+func (e *Error) Error() string {
+	var b strings.Builder
+	b.WriteString(sqlite3_wrap.ErrorCodeString(e.code))
+
+	if e.msg != "" {
+		b.WriteString(": ")
+		b.WriteString(e.msg)
+	}
+	if e.sys != nil {
+		b.WriteString(": ")
+		b.WriteString(e.sys.Error())
+	}
+
+	return b.String()
+}
+
+// Unwrap returns the underlying operating system error
+// that caused the I/O error or failure to open a file.
+//
+// https://sqlite.org/c3ref/system_errno.html
+func (e *Error) Unwrap() error {
+	return e.sys
+}
+
+// Is tests whether this error matches a given [ErrorCode] or [ExtendedErrorCode].
+//
+// It makes it possible to do:
+//
+//	if errors.Is(err, sqlite3.BUSY) {
+//		// ... handle BUSY
+//	}
+func (e *Error) Is(err error) bool {
+	switch c := err.(type) {
+	case ErrorCode:
+		return c == e.Code()
+	case ExtendedErrorCode:
+		return c == e.ExtendedCode()
+	}
+	return false
+}
+
+// As converts this error to an [ErrorCode] or [ExtendedErrorCode].
+func (e *Error) As(err any) bool {
+	switch c := err.(type) {
+	case *ErrorCode:
+		*c = e.Code()
+		return true
+	case *ExtendedErrorCode:
+		*c = e.ExtendedCode()
+		return true
+	}
+	return false
+}
+
+// Temporary returns true for [BUSY] errors.
+func (e *Error) Temporary() bool {
+	return e.Code() == BUSY || e.Code() == INTERRUPT
+}
+
+// Timeout returns true for [BUSY_TIMEOUT] errors.
+func (e *Error) Timeout() bool {
+	return e.ExtendedCode() == BUSY_TIMEOUT
+}
+
+// SQL returns the SQL starting at the token that triggered a syntax error.
+func (e *Error) SQL() string {
+	return e.sql
+}
+
+// Error implements the error interface.
+func (e ErrorCode) Error() string {
+	return sqlite3_wrap.ErrorCodeString(e)
+}
+
+// As converts this error to an [ExtendedErrorCode].
+func (e ErrorCode) As(err any) bool {
+	c, ok := err.(*xErrorCode)
+	if ok {
+		*c = xErrorCode(e)
+	}
+	return ok
+}
+
+// Temporary returns true for [BUSY] errors.
+func (e ErrorCode) Temporary() bool {
+	return e == BUSY || e == INTERRUPT
+}
+
+// ExtendedCode returns the extended error code for this error.
+func (e ErrorCode) ExtendedCode() ExtendedErrorCode {
+	return xErrorCode(e)
+}
+
+// Error implements the error interface.
+func (e ExtendedErrorCode) Error() string {
+	return sqlite3_wrap.ErrorCodeString(e)
+}
+
+// Is tests whether this error matches a given [ErrorCode].
+func (e ExtendedErrorCode) Is(err error) bool {
+	c, ok := err.(ErrorCode)
+	return ok && c == ErrorCode(e)
+}
+
+// As converts this error to an [ErrorCode].
+func (e ExtendedErrorCode) As(err any) bool {
+	c, ok := err.(*ErrorCode)
+	if ok {
+		*c = ErrorCode(e)
+	}
+	return ok
+}
+
+// Temporary returns true for [BUSY] errors.
+func (e ExtendedErrorCode) Temporary() bool {
+	return ErrorCode(e) == BUSY || ErrorCode(e) == INTERRUPT
+}
+
+// Timeout returns true for [BUSY_TIMEOUT] errors.
+func (e ExtendedErrorCode) Timeout() bool {
+	return e == BUSY_TIMEOUT
+}
+
+// Code returns the primary error code for this error.
+func (e ExtendedErrorCode) Code() ErrorCode {
+	return ErrorCode(e)
+}
+
+func errorCode(err error, def ErrorCode) (msg string, code res_t) {
+	switch code := err.(type) {
+	case nil:
+		return "", _OK
+	case ErrorCode:
+		return "", res_t(code)
+	case xErrorCode:
+		return "", res_t(code)
+	case *Error:
+		return code.msg, res_t(code.code)
+	}
+
+	var xcode xErrorCode
+	if errors.As(err, &xcode) {
+		code = res_t(xcode)
+	} else {
+		code = res_t(def)
+	}
+	return err.Error(), code
+}

package/govendor/github.com/ncruces/go-sqlite3/ext.go

@@ -0,0 +1,153 @@
+package sqlite3
+
+import (
+	"bytes"
+	"encoding/base64"
+	"sync"
+
+	"github.com/ncruces/go-sqlite3/internal/errutil"
+	"github.com/ncruces/go-sqlite3/internal/sqlite3_wrap"
+)
+
+var (
+	// +checklocks:extRegistryMtx
+	extRegistry    []func(*Conn) error
+	extRegistryMtx sync.RWMutex
+)
+
+// AutoExtension causes the entryPoint function to be invoked
+// for each new database connection that is created.
+//
+// https://sqlite.org/c3ref/auto_extension.html
+func AutoExtension(entryPoint func(*Conn) error) {
+	extRegistryMtx.Lock()
+	extRegistry = append(extRegistry, entryPoint)
+	extRegistryMtx.Unlock()
+}
+
+func initExtensions(c *Conn) error {
+	c.uuid()
+	c.base64()
+	extRegistryMtx.RLock()
+	defer extRegistryMtx.RUnlock()
+	for _, f := range extRegistry {
+		if err := f(c); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (c *Conn) base64() error {
+	return c.CreateFunction("base64", 1, DETERMINISTIC, func(ctx Context, arg ...Value) {
+		switch a := arg[0]; a.Type() {
+		case NULL:
+
+		case BLOB:
+			data := a.RawBlob()
+			code := base64.StdEncoding
+			size := int64(code.EncodedLen(len(data)))
+			if size > _MAX_LENGTH {
+				ctx.ResultError(TOOBIG)
+				return
+			}
+			ptr := c.wrp.New(size)
+			if size > 0 {
+				code.Encode(c.wrp.Bytes(ptr, size), data)
+			}
+			ctx.c.wrp.Xsqlite3_result_text_go(int32(ctx.handle), int32(ptr), size)
+
+		case TEXT:
+			data := a.RawText()
+			data = bytes.Trim(data, " \t\n\v\f\r")
+			data = bytes.TrimRight(data, "=")
+			code := base64.RawStdEncoding
+			size := int64(code.DecodedLen(len(data)))
+			if size > _MAX_LENGTH {
+				ctx.ResultError(TOOBIG)
+				return
+			}
+			ptr := c.wrp.New(size)
+			if size > 0 {
+				n, _ := code.Decode(c.wrp.Bytes(ptr, size), data)
+				size = int64(n)
+			}
+			ctx.c.wrp.Xsqlite3_result_blob_go(int32(ctx.handle), int32(ptr), size)
+
+		default:
+			ctx.ResultError(errutil.ErrorString("base64: accepts only blob or text"))
+		}
+	})
+}
+
+// ExtensionLibrary represents a dynamically linked SQLite extension.
+type ExtensionLibrary interface {
+	Xsqlite3_extension_init(db, _, _ int32) int32
+}
+
+// ExtensionInfo returns values needed to load a dynamically linked SQLite extension.
+type ExtensionInfo func() (memorySize, memoryAlignment, tableSize, tableAlignment int64)
+
+// ExtEnv is the concrete type passed to [ExtensionInit] initializers.
+//
+// ExtEnv exposes undocumented internal APIs that are subject to change without notice.
+type ExtEnv struct {
+	*sqlite3_wrap.Wrapper
+	memoryBase int32
+	tableBase  int32
+}
+
+func (e *ExtEnv) X__memory_base() *int32 { return &e.memoryBase }
+func (e *ExtEnv) X__table_base() *int32  { return &e.tableBase }
+
+// CallWithContextValues calls fn with a [Context] and [Value] arguments decoded from pointers.
+func (e *ExtEnv) CallWithContextValues(pCtx, nVal, pVal int32, fn func(Context, ...Value)) {
+	db := e.DB.(*Conn)
+	args := callbackArgs(db, nVal, ptr_t(pVal))
+	defer returnArgs(args)
+	fn(Context{db, ptr_t(pCtx)}, *args...)
+}
+
+// ExtensionInit loads an SQLite extension library.
+//
+// https://sqlite.org/loadext.html
+//
+// Deprecated: use the generic method.
+func ExtensionInit[Env any, Mod ExtensionLibrary](db *Conn, init func(env Env) Mod, info ExtensionInfo) error {
+	memSize, memAlign, tableSize, tableAlign := info()
+
+	var memBase int32
+	if memSize > 0 {
+		memBase = db.wrp.Xmemalign(int32(memAlign), int32(memSize))
+		if memBase == 0 {
+			panic(errutil.OOMErr)
+		}
+	}
+
+	var tableBase int
+	if tableSize > 0 {
+		// Round up to the alignment.
+		rnd := int(tableAlign) - 1
+		tab := db.wrp.X__indirect_function_table()
+		tableBase = (len(*tab) + rnd) &^ rnd
+		if add := tableBase + int(tableSize) - len(*tab); add > 0 {
+			*tab = append(*tab, make([]any, add)...)
+		}
+	}
+
+	e := &ExtEnv{
+		Wrapper:    db.wrp,
+		memoryBase: memBase,
+		tableBase:  int32(tableBase),
+	}
+
+	mod := init(any(e).(Env))
+	if opt, ok := any(mod).(interface{ X__wasm_apply_data_relocs() }); ok {
+		opt.X__wasm_apply_data_relocs()
+	}
+	if opt, ok := any(mod).(interface{ X__wasm_call_ctors() }); ok {
+		opt.X__wasm_call_ctors()
+	}
+	rc := mod.Xsqlite3_extension_init(int32(db.handle), 0, 0)
+	return db.error(res_t(rc))
+}

package/govendor/github.com/ncruces/go-sqlite3/func.go

@@ -0,0 +1,309 @@
+package sqlite3
+
+import (
+	"bytes"
+	"io"
+	"iter"
+	"sync"
+	"sync/atomic"
+
+	"github.com/ncruces/go-sqlite3/internal/errutil"
+)
+
+// CollationNeeded registers a callback to be invoked
+// whenever an unknown collation sequence is required.
+//
+// https://sqlite.org/c3ref/collation_needed.html
+func (c *Conn) CollationNeeded(cb func(db *Conn, name string)) error {
+	var enable int32
+	if cb != nil {
+		enable = 1
+	}
+	rc := res_t(c.wrp.Xsqlite3_collation_needed_go(int32(c.handle), enable))
+	if err := c.error(rc); err != nil {
+		return err
+	}
+	c.collation = cb
+	return nil
+}
+
+// AnyCollationNeeded uses [Conn.CollationNeeded] to register
+// a fake collating function for any unknown collating sequence.
+// The fake collating function works like BINARY.
+//
+// This can be used to load schemas that contain
+// one or more unknown collating sequences.
+func (c *Conn) AnyCollationNeeded() error {
+	return c.CollationNeeded(func(db *Conn, name string) {
+		db.CreateCollation(name, bytes.Compare)
+	})
+}
+
+// CreateCollation defines a new collating sequence.
+//
+// https://sqlite.org/c3ref/create_collation.html
+func (c *Conn) CreateCollation(name string, fn CollatingFunction) error {
+	var funcPtr ptr_t
+	defer c.arena.Mark()()
+	namePtr := c.arena.String(name)
+	if fn != nil {
+		funcPtr = c.wrp.AddHandle(fn)
+	}
+	rc := res_t(c.wrp.Xsqlite3_create_collation_go(
+		int32(c.handle), int32(namePtr), int32(funcPtr)))
+	return c.error(rc)
+}
+
+// CollatingFunction is the type of a collation callback.
+// Implementations must not retain a or b.
+type CollatingFunction func(a, b []byte) int
+
+// CreateFunction defines a new scalar SQL function.
+//
+// https://sqlite.org/c3ref/create_function.html
+func (c *Conn) CreateFunction(name string, nArg int, flag FunctionFlag, fn ScalarFunction) error {
+	var funcPtr ptr_t
+	defer c.arena.Mark()()
+	namePtr := c.arena.String(name)
+	if fn != nil {
+		funcPtr = c.wrp.AddHandle(fn)
+	}
+	rc := res_t(c.wrp.Xsqlite3_create_function_go(
+		int32(c.handle), int32(namePtr), int32(nArg),
+		int32(flag), int32(funcPtr)))
+	return c.error(rc)
+}
+
+// ScalarFunction is the type of a scalar SQL function.
+// Implementations must not retain arg.
+type ScalarFunction func(ctx Context, arg ...Value)
+
+// CreateAggregateFunction defines a new aggregate SQL function.
+//
+// https://sqlite.org/c3ref/create_function.html
+func (c *Conn) CreateAggregateFunction(name string, nArg int, flag FunctionFlag, fn AggregateSeqFunction) error {
+	var funcPtr ptr_t
+	defer c.arena.Mark()()
+	namePtr := c.arena.String(name)
+	if fn != nil {
+		funcPtr = c.wrp.AddHandle(AggregateConstructor(func() AggregateFunction {
+			a := aggregateFunc{fn: fn}
+			coro := func(yieldCoro func(struct{}) bool) {
+				seq := func(yieldSeq func([]Value) bool) {
+					for yieldSeq(a.arg) {
+						if !yieldCoro(struct{}{}) {
+							break
+						}
+					}
+				}
+				fn(&a.ctx, seq)
+			}
+			a.next, a.stop = iter.Pull(coro)
+			return &a
+		}))
+	}
+	rc := res_t(c.wrp.Xsqlite3_create_aggregate_function_go(
+		int32(c.handle), int32(namePtr), int32(nArg),
+		int32(flag), int32(funcPtr)))
+	return c.error(rc)
+}
+
+// AggregateSeqFunction is the type of an aggregate SQL function.
+// Implementations must not retain the slices yielded by seq.
+type AggregateSeqFunction func(ctx *Context, seq iter.Seq[[]Value])
+
+// CreateWindowFunction defines a new aggregate or aggregate window SQL function.
+// If fn returns a [WindowFunction], an aggregate window function is created.
+// If fn returns an [io.Closer], it will be called to free resources.
+//
+// https://sqlite.org/c3ref/create_function.html
+func (c *Conn) CreateWindowFunction(name string, nArg int, flag FunctionFlag, fn AggregateConstructor) error {
+	var funcPtr ptr_t
+	defer c.arena.Mark()()
+	namePtr := c.arena.String(name)
+	if fn != nil {
+		funcPtr = c.wrp.AddHandle(fn)
+	}
+	rc := res_t(c.wrp.Xsqlite3_create_window_function_go(
+		int32(c.handle), int32(namePtr), int32(nArg),
+		int32(flag), int32(funcPtr)))
+	return c.error(rc)
+}
+
+// AggregateConstructor is a an [AggregateFunction] constructor.
+type AggregateConstructor func() AggregateFunction
+
+// AggregateFunction is the interface an aggregate function should implement.
+//
+// https://sqlite.org/appfunc.html
+type AggregateFunction interface {
+	// Step is invoked to add a row to the current window.
+	// The function arguments, if any, corresponding to the row being added, are passed to Step.
+	// Implementations must not retain arg.
+	Step(ctx Context, arg ...Value)
+
+	// Value is invoked to return the current (or final) value of the aggregate.
+	Value(ctx Context)
+}
+
+// WindowFunction is the interface an aggregate window function should implement.
+//
+// https://sqlite.org/windowfunctions.html
+type WindowFunction interface {
+	AggregateFunction
+
+	// Inverse is invoked to remove the oldest presently aggregated result of Step from the current window.
+	// The function arguments, if any, are those passed to Step for the row being removed.
+	// Implementations must not retain arg.
+	Inverse(ctx Context, arg ...Value)
+}
+
+// OverloadFunction overloads a function for a virtual table.
+//
+// https://sqlite.org/c3ref/overload_function.html
+func (c *Conn) OverloadFunction(name string, nArg int) error {
+	defer c.arena.Mark()()
+	namePtr := c.arena.String(name)
+	rc := res_t(c.wrp.Xsqlite3_overload_function(
+		int32(c.handle), int32(namePtr), int32(nArg)))
+	return c.error(rc)
+}
+
+func (e env) Xgo_collation_needed(pArg, pDB, eTextRep, zName int32) {
+	if c, ok := e.DB.(*Conn); ok && c.handle == ptr_t(pDB) && c.collation != nil {
+		name := e.ReadString(ptr_t(zName), _MAX_NAME)
+		c.collation(c, name)
+	}
+}
+
+func (e env) Xgo_compare(pApp, nKey1, pKey1, nKey2, pKey2 int32) int32 {
+	fn := e.GetHandle(ptr_t(pApp)).(CollatingFunction)
+	return int32(fn(
+		e.Bytes(ptr_t(pKey1), int64(nKey1)),
+		e.Bytes(ptr_t(pKey2), int64(nKey2))))
+}
+
+func (e env) Xgo_func(pCtx, pApp, nArg, pArg int32) {
+	db := e.DB.(*Conn)
+	args := callbackArgs(db, nArg, ptr_t(pArg))
+	defer returnArgs(args)
+	fn := db.wrp.GetHandle(ptr_t(pApp)).(ScalarFunction)
+	fn(Context{db, ptr_t(pCtx)}, *args...)
+}
+
+func (e env) Xgo_step(pCtx, pAgg, pApp, nArg, pArg int32) {
+	db := e.DB.(*Conn)
+	args := callbackArgs(db, nArg, ptr_t(pArg))
+	defer returnArgs(args)
+	fn, _ := callbackAggregate(db, ptr_t(pAgg), ptr_t(pApp))
+	fn.Step(Context{db, ptr_t(pCtx)}, *args...)
+}
+
+func (e env) Xgo_value(pCtx, pAgg, pApp, final int32) {
+	db := e.DB.(*Conn)
+	fn, handle := callbackAggregate(db, ptr_t(pAgg), ptr_t(pApp))
+	fn.Value(Context{db, ptr_t(pCtx)})
+
+	// Cleanup.
+	if final != 0 {
+		var err error
+		if handle != 0 {
+			err = e.DelHandle(handle)
+		} else if c, ok := fn.(io.Closer); ok {
+			err = c.Close()
+		}
+		if err != nil {
+			Context{db, ptr_t(pCtx)}.ResultError(err)
+			return // notest
+		}
+	}
+}
+
+func (e env) Xgo_inverse(pCtx, pAgg, nArg, pArg int32) {
+	db := e.DB.(*Conn)
+	args := callbackArgs(db, nArg, ptr_t(pArg))
+	defer returnArgs(args)
+	fn, ok := db.wrp.GetHandle(ptr_t(pAgg)).(WindowFunction)
+	if !ok {
+		Context{db, ptr_t(pCtx)}.ResultError(
+			errutil.ErrorString("may not be used as a window function"))
+		return // notest
+	}
+	fn.Inverse(Context{db, ptr_t(pCtx)}, *args...)
+}
+
+func callbackAggregate(db *Conn, pAgg, pApp ptr_t) (AggregateFunction, ptr_t) {
+	if pApp == 0 {
+		handle := ptr_t(db.wrp.Read32(pAgg))
+		return db.wrp.GetHandle(handle).(AggregateFunction), handle
+	}
+
+	// We need to create the aggregate.
+	fn := db.wrp.GetHandle(pApp).(AggregateConstructor)()
+	if pAgg != 0 {
+		handle := db.wrp.AddHandle(fn)
+		db.wrp.Write32(pAgg, uint32(handle))
+		return fn, handle
+	}
+	return fn, 0
+}
+
+var (
+	valueArgsPool sync.Pool
+	valueArgsLen  atomic.Int32
+)
+
+func callbackArgs(db *Conn, nArg int32, pArg ptr_t) *[]Value {
+	arg, ok := valueArgsPool.Get().(*[]Value)
+	if !ok || cap(*arg) < int(nArg) {
+		max := valueArgsLen.Or(nArg) | nArg
+		lst := make([]Value, max)
+		arg = &lst
+	}
+	lst := (*arg)[:nArg]
+	for i := range lst {
+		lst[i] = Value{
+			c:      db,
+			handle: ptr_t(db.wrp.Read32(pArg + ptr_t(i)*ptrlen)),
+		}
+	}
+	*arg = lst
+	return arg
+}
+
+func returnArgs(p *[]Value) {
+	valueArgsPool.Put(p)
+}
+
+type aggregateFunc struct {
+	next func() (struct{}, bool)
+	stop func()
+	fn   AggregateSeqFunction
+	ctx  Context
+	arg  []Value
+	step bool
+}
+
+func (a *aggregateFunc) Step(ctx Context, arg ...Value) {
+	a.step = true
+	a.ctx = ctx
+	a.arg = append(a.arg[:0], arg...)
+	if _, more := a.next(); !more {
+		a.stop()
+	}
+}
+
+func (a *aggregateFunc) Value(ctx Context) {
+	a.ctx = ctx
+	a.stop()
+	if !a.step {
+		a.fn(&a.ctx, noValuesSeq)
+	}
+}
+
+func (a *aggregateFunc) Close() error {
+	a.stop()
+	return nil
+}
+
+func noValuesSeq(func([]Value) bool) {}

package/govendor/github.com/ncruces/go-sqlite3/go.mod

@@ -0,0 +1,3 @@
+module github.com/ncruces/go-sqlite3
+
+go 1.26.0

package/govendor/github.com/ncruces/go-sqlite3/internal/dotlk/dotlk.go

@@ -0,0 +1,29 @@
+package dotlk
+
+import (
+	"errors"
+	"io/fs"
+	"os"
+)
+
+// LockShm creates a directory on disk to prevent SQLite
+// from using this path for a shared memory file.
+func LockShm(name string) error {
+	err := os.Mkdir(name, 0777)
+	if errors.Is(err, fs.ErrExist) {
+		s, err := os.Lstat(name)
+		if err == nil && s.IsDir() {
+			return nil
+		}
+	}
+	return err
+}
+
+// Unlock removes the lock or shared memory file.
+func Unlock(name string) error {
+	err := os.Remove(name)
+	if errors.Is(err, fs.ErrNotExist) {
+		return nil
+	}
+	return err
+}

package/govendor/github.com/ncruces/go-sqlite3/internal/dotlk/dotlk_other.go

@@ -0,0 +1,13 @@
+//go:build !unix
+
+package dotlk
+
+import "os"
+
+// TryLock returns nil if it acquired the lock,
+// fs.ErrExist if another process has the lock.
+func TryLock(name string) error {
+	f, err := os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0666)
+	f.Close()
+	return err
+}