typenative 0.1.3 → 0.2.0

package/govendor/github.com/ncruces/go-sqlite3/internal/sqlite3_wrap/wrap_vfs.go

@@ -0,0 +1,181 @@
+package sqlite3_wrap
+
+import (
+	"crypto/rand"
+	"time"
+	_ "unsafe"
+
+	"github.com/ncruces/julianday"
+)
+
+func (w *Wrapper) Xgo_randomness(pVfs, nByte, zByte int32) int32 {
+	mem := w.Bytes(Ptr_t(zByte), int64(nByte))
+	n, _ := rand.Reader.Read(mem)
+	return int32(n)
+}
+
+func (w *Wrapper) Xgo_sleep(pVfs, nMicro int32) int32 {
+	time.Sleep(time.Duration(nMicro) * time.Microsecond)
+	return OK
+}
+
+func (w *Wrapper) Xgo_current_time_64(pVfs, nMicro int32) int32 {
+	day, nsec := julianday.Date(time.Now())
+	msec := day*86_400_000 + nsec/1_000_000
+	w.Write64(Ptr_t(nMicro), uint64(msec))
+	return OK
+}
+
+//go:linkname vfsFullPathname github.com/ncruces/go-sqlite3/vfs.vfsFullPathname
+func vfsFullPathname(_ *Wrapper, v0, v1, v2, v3 int32) int32
+
+func (w *Wrapper) Xgo_full_pathname(v0, v1, v2, v3 int32) int32 {
+	return vfsFullPathname(w, v0, v1, v2, v3)
+}
+
+//go:linkname vfsDelete github.com/ncruces/go-sqlite3/vfs.vfsDelete
+func vfsDelete(_ *Wrapper, v0, v1, v2 int32) int32
+
+func (w *Wrapper) Xgo_delete(v0, v1, v2 int32) int32 {
+	return vfsDelete(w, v0, v1, v2)
+}
+
+//go:linkname vfsAccess github.com/ncruces/go-sqlite3/vfs.vfsAccess
+func vfsAccess(_ *Wrapper, v0, v1, v2, v3 int32) int32
+
+func (w *Wrapper) Xgo_access(v0, v1, v2, v3 int32) int32 {
+	return vfsAccess(w, v0, v1, v2, v3)
+}
+
+//go:linkname vfsOpen github.com/ncruces/go-sqlite3/vfs.vfsOpen
+func vfsOpen(_ *Wrapper, v0, v1, v2, v3, v4, v5 int32) int32
+
+func (w *Wrapper) Xgo_open(v0, v1, v2, v3, v4, v5 int32) int32 {
+	return vfsOpen(w, v0, v1, v2, v3, v4, v5)
+}
+
+//go:linkname vfsClose github.com/ncruces/go-sqlite3/vfs.vfsClose
+func vfsClose(_ *Wrapper, v0 int32) int32
+
+func (w *Wrapper) Xgo_close(v0 int32) int32 {
+	return vfsClose(w, v0)
+}
+
+//go:linkname vfsRead github.com/ncruces/go-sqlite3/vfs.vfsRead
+func vfsRead(_ *Wrapper, v0, v1, v2 int32, v3 int64) int32
+
+func (w *Wrapper) Xgo_read(v0, v1, v2 int32, v3 int64) int32 {
+	return vfsRead(w, v0, v1, v2, v3)
+}
+
+//go:linkname vfsWrite github.com/ncruces/go-sqlite3/vfs.vfsWrite
+func vfsWrite(_ *Wrapper, v0, v1, v2 int32, v3 int64) int32
+
+func (w *Wrapper) Xgo_write(v0, v1, v2 int32, v3 int64) int32 {
+	return vfsWrite(w, v0, v1, v2, v3)
+}
+
+//go:linkname vfsTruncate github.com/ncruces/go-sqlite3/vfs.vfsTruncate
+func vfsTruncate(_ *Wrapper, v0 int32, v1 int64) int32
+
+func (w *Wrapper) Xgo_truncate(v0 int32, v1 int64) int32 {
+	return vfsTruncate(w, v0, v1)
+}
+
+//go:linkname vfsSync github.com/ncruces/go-sqlite3/vfs.vfsSync
+func vfsSync(_ *Wrapper, v0, v1 int32) int32
+
+func (w *Wrapper) Xgo_sync(v0, v1 int32) int32 {
+	return vfsSync(w, v0, v1)
+}
+
+//go:linkname vfsFileSize github.com/ncruces/go-sqlite3/vfs.vfsFileSize
+func vfsFileSize(_ *Wrapper, v0, v1 int32) int32
+
+func (w *Wrapper) Xgo_file_size(v0, v1 int32) int32 {
+	return vfsFileSize(w, v0, v1)
+}
+
+//go:linkname vfsLock github.com/ncruces/go-sqlite3/vfs.vfsLock
+func vfsLock(_ *Wrapper, v0, v1 int32) int32
+
+func (w *Wrapper) Xgo_lock(v0, v1 int32) int32 {
+	return vfsLock(w, v0, v1)
+}
+
+//go:linkname vfsUnlock github.com/ncruces/go-sqlite3/vfs.vfsUnlock
+func vfsUnlock(_ *Wrapper, v0, v1 int32) int32
+
+func (w *Wrapper) Xgo_unlock(v0, v1 int32) int32 {
+	return vfsUnlock(w, v0, v1)
+}
+
+//go:linkname vfsCheckReservedLock github.com/ncruces/go-sqlite3/vfs.vfsCheckReservedLock
+func vfsCheckReservedLock(_ *Wrapper, v0, v1 int32) int32
+
+func (w *Wrapper) Xgo_check_reserved_lock(v0, v1 int32) int32 {
+	return vfsCheckReservedLock(w, v0, v1)
+}
+
+//go:linkname vfsFileControl github.com/ncruces/go-sqlite3/vfs.vfsFileControl
+func vfsFileControl(_ *Wrapper, v0, v1, v2 int32) int32
+
+func (w *Wrapper) Xgo_file_control(v0, v1, v2 int32) int32 {
+	return vfsFileControl(w, v0, v1, v2)
+}
+
+//go:linkname vfsSectorSize github.com/ncruces/go-sqlite3/vfs.vfsSectorSize
+func vfsSectorSize(_ *Wrapper, v0 int32) int32
+
+func (w *Wrapper) Xgo_sector_size(v0 int32) int32 {
+	return vfsSectorSize(w, v0)
+}
+
+//go:linkname vfsDeviceCharacteristics github.com/ncruces/go-sqlite3/vfs.vfsDeviceCharacteristics
+func vfsDeviceCharacteristics(_ *Wrapper, v0 int32) int32
+
+func (w *Wrapper) Xgo_device_characteristics(v0 int32) int32 {
+	return vfsDeviceCharacteristics(w, v0)
+}
+
+//go:linkname vfsShmBarrier github.com/ncruces/go-sqlite3/vfs.vfsShmBarrier
+func vfsShmBarrier(_ *Wrapper, v0 int32)
+
+func (w *Wrapper) Xgo_shm_barrier(v0 int32) {
+	vfsShmBarrier(w, v0)
+}
+
+//go:linkname vfsShmMap github.com/ncruces/go-sqlite3/vfs.vfsShmMap
+func vfsShmMap(_ *Wrapper, v0, v1, v2, v3, v4 int32) int32
+
+func (w *Wrapper) Xgo_shm_map(v0, v1, v2, v3, v4 int32) int32 {
+	return vfsShmMap(w, v0, v1, v2, v3, v4)
+}
+
+//go:linkname vfsShmLock github.com/ncruces/go-sqlite3/vfs.vfsShmLock
+func vfsShmLock(_ *Wrapper, v0, v1, v2, v3 int32) int32
+
+func (w *Wrapper) Xgo_shm_lock(v0, v1, v2, v3 int32) int32 {
+	return vfsShmLock(w, v0, v1, v2, v3)
+}
+
+//go:linkname vfsShmUnmap github.com/ncruces/go-sqlite3/vfs.vfsShmUnmap
+func vfsShmUnmap(_ *Wrapper, v0, v1 int32) int32
+
+func (w *Wrapper) Xgo_shm_unmap(v0, v1 int32) int32 {
+	return vfsShmUnmap(w, v0, v1)
+}
+
+//go:linkname vfsFetch github.com/ncruces/go-sqlite3/vfs.vfsFetch
+func vfsFetch(_ *Wrapper, v0 int32, v1 int64, v2, v3 int32) int32
+
+func (w *Wrapper) Xgo_fetch(v0 int32, v1 int64, v2, v3 int32) int32 {
+	return vfsFetch(w, v0, v1, v2, v3)
+}
+
+//go:linkname vfsUnfetch github.com/ncruces/go-sqlite3/vfs.vfsUnfetch
+func vfsUnfetch(_ *Wrapper, v0 int32, v1 int64, v2 int32) int32
+
+func (w *Wrapper) Xgo_unfetch(v0 int32, v1 int64, v2 int32) int32 {
+	return vfsUnfetch(w, v0, v1, v2)
+}

package/govendor/github.com/ncruces/go-sqlite3/internal/testenv/env.go

@@ -0,0 +1,55 @@
+package testenv
+
+import (
+	"bytes"
+	"context"
+	"io/fs"
+	"sync"
+)
+
+type Context interface {
+	Context() context.Context
+	Logf(format string, args ...any)
+}
+
+var (
+	FS     fs.FS
+	TB     Context
+	Exit   func(int32)
+	System func(string) int32
+
+	buf []byte
+	mtx sync.Mutex
+)
+
+func WriteByte(c byte) error {
+	mtx.Lock()
+	defer mtx.Unlock()
+
+	if c == '\n' {
+		TB.Logf("%s", buf)
+		buf = buf[:0]
+	} else {
+		buf = append(buf, c)
+	}
+	return nil
+}
+
+func Write(p []byte) (n int, err error) {
+	mtx.Lock()
+	defer mtx.Unlock()
+
+	buf = append(buf, p...)
+	for {
+		before, after, found := bytes.Cut(buf, []byte("\n"))
+		if !found {
+			return len(p), nil
+		}
+		TB.Logf("%s", before)
+		buf = after
+	}
+}
+
+func WriteString(s string) (n int, err error) {
+	return Write([]byte(s))
+}

package/govendor/github.com/ncruces/go-sqlite3/internal/util/json.go

@@ -0,0 +1,54 @@
+//go:build !go1.27
+
+package util
+
+import (
+	"encoding/json"
+	"math"
+	"strconv"
+	"time"
+	"unsafe"
+
+	"github.com/ncruces/go-sqlite3/internal/errutil"
+)
+
+type JSON struct{ Value any }
+
+func (j JSON) Scan(value any) error {
+	var buf []byte
+
+	switch v := value.(type) {
+	case []byte:
+		buf = v
+	case string:
+		buf = unsafe.Slice(unsafe.StringData(v), len(v))
+	case int64:
+		buf = strconv.AppendInt(nil, v, 10)
+	case float64:
+		buf = AppendNumber(nil, v)
+	case time.Time:
+		buf = append(buf, '"')
+		buf = v.AppendFormat(buf, time.RFC3339Nano)
+		buf = append(buf, '"')
+	case nil:
+		buf = []byte("null")
+	default:
+		panic(errutil.AssertErr())
+	}
+
+	return json.Unmarshal(buf, j.Value)
+}
+
+func AppendNumber(dst []byte, f float64) []byte {
+	switch {
+	case math.IsNaN(f):
+		dst = append(dst, "null"...)
+	case math.IsInf(f, 1):
+		dst = append(dst, "9.0e999"...)
+	case math.IsInf(f, -1):
+		dst = append(dst, "-9.0e999"...)
+	default:
+		return strconv.AppendFloat(dst, f, 'g', -1, 64)
+	}
+	return dst
+}

package/govendor/github.com/ncruces/go-sqlite3/internal/util/json_v2.go

@@ -0,0 +1,54 @@
+//go:build go1.27
+
+package util
+
+import (
+	"encoding/json/v2"
+	"math"
+	"strconv"
+	"time"
+	"unsafe"
+
+	"github.com/ncruces/go-sqlite3/internal/errutil"
+)
+
+type JSON struct{ Value any }
+
+func (j JSON) Scan(value any) error {
+	var buf []byte
+
+	switch v := value.(type) {
+	case []byte:
+		buf = v
+	case string:
+		buf = unsafe.Slice(unsafe.StringData(v), len(v))
+	case int64:
+		buf = strconv.AppendInt(nil, v, 10)
+	case float64:
+		buf = AppendNumber(nil, v)
+	case time.Time:
+		buf = append(buf, '"')
+		buf = v.AppendFormat(buf, time.RFC3339Nano)
+		buf = append(buf, '"')
+	case nil:
+		buf = []byte("null")
+	default:
+		panic(errutil.AssertErr())
+	}
+
+	return json.Unmarshal(buf, j.Value)
+}
+
+func AppendNumber(dst []byte, f float64) []byte {
+	switch {
+	case math.IsNaN(f):
+		dst = append(dst, "null"...)
+	case math.IsInf(f, 1):
+		dst = append(dst, "9.0e999"...)
+	case math.IsInf(f, -1):
+		dst = append(dst, "-9.0e999"...)
+	default:
+		return strconv.AppendFloat(dst, f, 'g', -1, 64)
+	}
+	return dst
+}

package/govendor/github.com/ncruces/go-sqlite3/internal/util/math.go

@@ -0,0 +1,29 @@
+package util
+
+import "math"
+
+func abs(n int) int {
+	if n < 0 {
+		return -n
+	}
+	return n
+}
+
+func GCD(m, n int) int {
+	for n != 0 {
+		m, n = n, m%n
+	}
+	return abs(m)
+}
+
+func LCM(m, n int) int {
+	if n == 0 {
+		return 0
+	}
+	return abs(n) * (abs(m) / GCD(m, n))
+}
+
+// https://developer.nvidia.com/blog/lerp-faster-cuda/
+func Lerp(v0, v1, t float64) float64 {
+	return math.FMA(t, v1, math.FMA(-t, v0, v0))
+}

package/govendor/github.com/ncruces/go-sqlite3/internal/util/page.go

@@ -0,0 +1,5 @@
+package util
+
+func ValidPageSize(s int) bool {
+	return s&(s-1) == 0 && 512 <= s && s <= 65536
+}

package/govendor/github.com/ncruces/go-sqlite3/internal/util/parse.go

@@ -0,0 +1,142 @@
+package util
+
+import (
+	"strconv"
+	"strings"
+	"time"
+)
+
+func ParseBool(s string) (b, ok bool) {
+	if len(s) == 0 {
+		return false, false
+	}
+	if s[0] == '0' {
+		return false, true
+	}
+	if '1' <= s[0] && s[0] <= '9' {
+		return true, true
+	}
+	switch strings.ToLower(s) {
+	case "true", "yes", "on":
+		return true, true
+	case "false", "no", "off":
+		return false, true
+	}
+	return false, false
+}
+
+func ParseFloat(s string) (f float64, ok bool) {
+	if strings.TrimLeft(s, "+-.0123456789Ee") != "" {
+		return
+	}
+	f, err := strconv.ParseFloat(s, 64)
+	return f, err == nil
+}
+
+func ParseTimeShift(s string) (years, months, days int, duration time.Duration, ok bool) {
+	// Sign part: ±
+	neg := strings.HasPrefix(s, "-")
+	sign := neg || strings.HasPrefix(s, "+")
+	if sign {
+		s = s[1:]
+	}
+
+	if ok = len(s) >= 5; !ok {
+		return // !ok
+	}
+
+	defer func() {
+		if neg {
+			years = -years
+			months = -months
+			days = -days
+			duration = -duration
+		}
+	}()
+
+	// Date part: YYYY-MM-DD
+	if s[4] == '-' {
+		if ok = sign && len(s) >= 10 && s[7] == '-'; !ok {
+			return // !ok
+		}
+		if years, ok = parseInt(s[0:4], 0); !ok {
+			return // !ok
+		}
+		if months, ok = parseInt(s[5:7], 12); !ok {
+			return // !ok
+		}
+		if days, ok = parseInt(s[8:10], 31); !ok {
+			return // !ok
+		}
+		if len(s) == 10 {
+			return
+		}
+		if ok = s[10] == ' '; !ok {
+			return // !ok
+		}
+		s = s[11:]
+	}
+
+	// Time part: HH:MM
+	if ok = len(s) >= 5 && s[2] == ':'; !ok {
+		return // !ok
+	}
+
+	var hours, minutes int
+	if hours, ok = parseInt(s[0:2], 24); !ok {
+		return
+	}
+	if minutes, ok = parseInt(s[3:5], 60); !ok {
+		return
+	}
+	duration = time.Duration(hours)*time.Hour + time.Duration(minutes)*time.Minute
+
+	if len(s) == 5 {
+		return
+	}
+	if ok = len(s) >= 8 && s[5] == ':'; !ok {
+		return // !ok
+	}
+
+	// Seconds part: HH:MM:SS
+	var seconds int
+	if seconds, ok = parseInt(s[6:8], 60); !ok {
+		return
+	}
+	duration += time.Duration(seconds) * time.Second
+
+	if len(s) == 8 {
+		return
+	}
+	if ok = len(s) >= 10 && s[8] == '.'; !ok {
+		return // !ok
+	}
+	s = s[9:]
+
+	// Nanosecond part: HH:MM:SS.SSS
+	var nanos int
+	if nanos, ok = parseInt(s[0:min(9, len(s))], 0); !ok {
+		return
+	}
+	for i := len(s); i < 9; i++ {
+		nanos *= 10
+	}
+	duration += time.Duration(nanos)
+
+	// Subnanosecond part.
+	if len(s) > 9 {
+		_, ok = parseInt(s[9:], 0)
+	}
+	return
+}
+
+func parseInt(s string, max int) (i int, _ bool) {
+	for _, r := range []byte(s) {
+		r -= '0'
+		if r > 9 {
+			return
+		}
+		i = i*10 + int(r)
+	}
+	return i, max == 0 || i < max
+}

package/govendor/github.com/ncruces/go-sqlite3/internal/util/pointer.go

@@ -0,0 +1,3 @@
+package util
+
+type Pointer struct{ Value any }

package/govendor/github.com/ncruces/go-sqlite3/internal/util/reflect.go

@@ -0,0 +1,10 @@
+package util
+
+import "reflect"
+
+func ReflectType(v reflect.Value) reflect.Type {
+	if v.Kind() != reflect.Invalid {
+		return v.Type()
+	}
+	return nil
+}

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

@@ -0,0 +1,100 @@
+//go:build !go1.27
+
+package sqlite3
+
+import (
+	"encoding/json"
+	"strconv"
+
+	"github.com/ncruces/go-sqlite3/internal/errutil"
+	"github.com/ncruces/go-sqlite3/internal/util"
+)
+
+// JSON returns a value that can be used as an argument to
+// [database/sql.DB.Exec], [database/sql.Row.Scan] and similar methods to
+// store value as JSON, or decode JSON into value.
+// JSON should NOT be used with [Stmt.BindJSON], [Stmt.ColumnJSON],
+// [Value.JSON], or [Context.ResultJSON].
+func JSON(value any) any {
+	return util.JSON{Value: value}
+}
+
+// ResultJSON sets the result of the function to the JSON encoding of value.
+//
+// If you return JSON from application-defined functions,
+// consider registering those functions with [RESULT_SUBTYPE]
+// and calling [Context.ResultSubtype] with 'J'.
+//
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultJSON(value any) {
+	err := json.NewEncoder(callbackWriter(func(p []byte) (int, error) {
+		ctx.ResultRawText(p[:len(p)-1]) // remove the newline
+		return 0, nil
+	})).Encode(value)
+
+	if err != nil {
+		ctx.ResultError(err)
+		return // notest
+	}
+}
+
+// BindJSON binds the JSON encoding of value to the prepared statement.
+// The leftmost SQL parameter has an index of 1.
+//
+// https://sqlite.org/c3ref/bind_blob.html
+func (s *Stmt) BindJSON(param int, value any) error {
+	return json.NewEncoder(callbackWriter(func(p []byte) (int, error) {
+		return 0, s.BindRawText(param, p[:len(p)-1]) // remove the newline
+	})).Encode(value)
+}
+
+// ColumnJSON parses the JSON-encoded value of the result column
+// and stores it in the value pointed to by ptr.
+// The leftmost column of the result set has the index 0.
+//
+// https://sqlite.org/c3ref/column_blob.html
+func (s *Stmt) ColumnJSON(col int, ptr any) error {
+	var data []byte
+	switch s.ColumnType(col) {
+	case NULL:
+		data = []byte("null")
+	case TEXT:
+		data = s.ColumnRawText(col)
+	case BLOB:
+		data = s.ColumnRawBlob(col)
+	case INTEGER:
+		data = strconv.AppendInt(nil, s.ColumnInt64(col), 10)
+	case FLOAT:
+		data = util.AppendNumber(nil, s.ColumnFloat(col))
+	default:
+		panic(errutil.AssertErr())
+	}
+	return json.Unmarshal(data, ptr)
+}
+
+// JSON parses a JSON-encoded value
+// and stores the result in the value pointed to by ptr.
+func (v Value) JSON(ptr any) error {
+	var data []byte
+	switch v.Type() {
+	case NULL:
+		data = []byte("null")
+	case TEXT:
+		data = v.RawText()
+	case BLOB:
+		data = v.RawBlob()
+	case INTEGER:
+		data = strconv.AppendInt(nil, v.Int64(), 10)
+	case FLOAT:
+		data = util.AppendNumber(nil, v.Float())
+	default:
+		panic(errutil.AssertErr())
+	}
+	return json.Unmarshal(data, ptr)
+}
+
+type callbackWriter func(p []byte) (int, error)
+
+func (fn callbackWriter) Write(p []byte) (int, error) { return fn(p) }
+
+func (c *Conn) uuid() error { return nil }