typenative 0.1.2 → 0.2.0

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

@@ -0,0 +1,57 @@
+//go:build unix
+
+package dotlk
+
+import (
+	"errors"
+	"io/fs"
+	"os"
+	"strconv"
+
+	"golang.org/x/sys/unix"
+)
+
+// TryLock returns nil if it acquired the lock,
+// fs.ErrExist if another process has the lock.
+func TryLock(name string) error {
+	for retry := true; retry; retry = false {
+		f, err := os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0666)
+		if err == nil {
+			f.WriteString(strconv.Itoa(os.Getpid()))
+			f.Close()
+			return nil
+		}
+		if !errors.Is(err, fs.ErrExist) {
+			return err
+		}
+		if !removeStale(name) {
+			break
+		}
+	}
+	return fs.ErrExist
+}
+
+func removeStale(name string) bool {
+	buf, err := os.ReadFile(name)
+	if err != nil {
+		return errors.Is(err, fs.ErrNotExist)
+	}
+
+	pid, err := strconv.Atoi(string(buf))
+	if pid <= 0 || err != nil {
+		return false
+	}
+
+	if pid == os.Getpid() {
+		err = os.Remove(name)
+		return err == nil || errors.Is(err, fs.ErrNotExist)
+	}
+
+	err = unix.Kill(pid, 0)
+	if errors.Is(err, unix.ESRCH) {
+		err = os.Remove(name)
+		return err == nil || errors.Is(err, fs.ErrNotExist)
+	}
+
+	return false
+}

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

@@ -0,0 +1,41 @@
+package errutil
+
+import (
+	"runtime"
+	"strconv"
+)
+
+type ErrorString string
+
+func (e ErrorString) Error() string { return string(e) }
+
+const (
+	NilErr       = ErrorString("sqlite3: invalid memory address or null pointer dereference")
+	OOMErr       = ErrorString("sqlite3: out of memory")
+	NoNulErr     = ErrorString("sqlite3: missing NUL terminator")
+	TimeErr      = ErrorString("sqlite3: invalid time value")
+	WhenceErr    = ErrorString("sqlite3: invalid whence")
+	OffsetErr    = ErrorString("sqlite3: invalid offset")
+	TailErr      = ErrorString("sqlite3: multiple statements")
+	IsolationErr = ErrorString("sqlite3: unsupported isolation level")
+	ValueErr     = ErrorString("sqlite3: unsupported value")
+	NoVFSErr     = ErrorString("sqlite3: no such vfs: ")
+)
+
+func AssertErr() ErrorString {
+	msg := "sqlite3: assertion failed"
+	if _, file, line, ok := runtime.Caller(1); ok {
+		msg += " (" + file + ":" + strconv.Itoa(line) + ")"
+	}
+	return ErrorString(msg)
+}
+
+type ErrorJoiner []error
+
+func (j *ErrorJoiner) Join(errs ...error) {
+	for _, err := range errs {
+		if err != nil {
+			*j = append(*j, err)
+		}
+	}
+}

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

@@ -0,0 +1,128 @@
+package sqlite3_wrap
+
+import "github.com/ncruces/go-sqlite3/internal/errutil"
+
+func (w *Wrapper) Free(ptr Ptr_t) {
+	if ptr == 0 {
+		return
+	}
+	w.Xsqlite3_free(int32(ptr))
+}
+
+func (w *Wrapper) New(size int64) Ptr_t {
+	ptr := Ptr_t(w.Xsqlite3_malloc64(size))
+	if ptr == 0 && size != 0 {
+		panic(errutil.OOMErr)
+	}
+	return ptr
+}
+
+func (w *Wrapper) Realloc(ptr Ptr_t, size int64) Ptr_t {
+	ptr = Ptr_t(w.Xsqlite3_realloc64(int32(ptr), size))
+	if ptr == 0 && size != 0 {
+		panic(errutil.OOMErr)
+	}
+	return ptr
+}
+
+func (w *Wrapper) NewBytes(b []byte) Ptr_t {
+	if len(b) == 0 {
+		return 0
+	}
+	ptr := w.New(int64(len(b)))
+	w.WriteBytes(ptr, b)
+	return ptr
+}
+
+func (w *Wrapper) NewString(s string) Ptr_t {
+	ptr := w.New(int64(len(s)) + 1)
+	w.WriteString(ptr, s)
+	return ptr
+}
+
+func (w *Wrapper) StackMark() (reset func()) {
+	ptr := w.X__stack_pointer()
+	old := *ptr
+	return func() { *ptr = old }
+}
+
+func (w *Wrapper) StackAlloc(size int64) Ptr_t {
+	ptr := w.X__stack_pointer()
+	new := int64(*ptr) - size
+	if size < 0 || new <= 0 {
+		panic(errutil.OOMErr)
+	}
+	*ptr = int32(new)
+	return Ptr_t(new)
+}
+
+const arenaSize = 4096
+
+func (w *Wrapper) NewArena() Arena {
+	return Arena{
+		sqlt: w,
+		base: w.New(arenaSize),
+	}
+}
+
+type Arena struct {
+	sqlt *Wrapper
+	ptrs []Ptr_t
+	base Ptr_t
+	next int32
+}
+
+func (a *Arena) Free() {
+	if a.sqlt == nil {
+		return
+	}
+	for _, ptr := range a.ptrs {
+		a.sqlt.Free(ptr)
+	}
+	a.sqlt.Free(a.base)
+	a.sqlt = nil
+}
+
+func (a *Arena) Mark() (reset func()) {
+	ptrs := len(a.ptrs)
+	next := a.next
+	return func() {
+		for _, ptr := range a.ptrs[ptrs:] {
+			a.sqlt.Free(ptr)
+		}
+		a.ptrs = a.ptrs[:ptrs]
+		a.next = next
+	}
+}
+
+func (a *Arena) New(size int64) Ptr_t {
+	// Align the next address, to 4 or 8 bytes.
+	if size&7 != 0 {
+		a.next = (a.next + 3) &^ 3
+	} else {
+		a.next = (a.next + 7) &^ 7
+	}
+	if size <= arenaSize-int64(a.next) {
+		ptr := a.base + Ptr_t(a.next)
+		a.next += int32(size)
+		return Ptr_t(ptr)
+	}
+	ptr := a.sqlt.New(size)
+	a.ptrs = append(a.ptrs, ptr)
+	return Ptr_t(ptr)
+}
+
+func (a *Arena) Bytes(b []byte) Ptr_t {
+	if len(b) == 0 {
+		return 0
+	}
+	ptr := a.New(int64(len(b)))
+	a.sqlt.WriteBytes(ptr, b)
+	return ptr
+}
+
+func (a *Arena) String(s string) Ptr_t {
+	ptr := a.New(int64(len(s)) + 1)
+	a.sqlt.WriteString(ptr, s)
+	return ptr
+}

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

@@ -0,0 +1,122 @@
+package sqlite3_wrap
+
+// https://sqlite.org/rescode.html
+const (
+	OK = 0 /* Successful result */
+
+	ERROR      = 1  /* Generic error */
+	INTERNAL   = 2  /* Internal logic error in SQLite */
+	PERM       = 3  /* Access permission denied */
+	ABORT      = 4  /* Callback routine requested an abort */
+	BUSY       = 5  /* The database file is locked */
+	LOCKED     = 6  /* A table in the database is locked */
+	NOMEM      = 7  /* A malloc() failed */
+	READONLY   = 8  /* Attempt to write a readonly database */
+	INTERRUPT  = 9  /* Operation terminated by sqlite3_interrupt() */
+	IOERR      = 10 /* Some kind of disk I/O error occurred */
+	CORRUPT    = 11 /* The database disk image is malformed */
+	NOTFOUND   = 12 /* Unknown opcode in sqlite3_file_control() */
+	FULL       = 13 /* Insertion failed because database is full */
+	CANTOPEN   = 14 /* Unable to open the database file */
+	PROTOCOL   = 15 /* Database lock protocol error */
+	EMPTY      = 16 /* Internal use only */
+	SCHEMA     = 17 /* The database schema changed */
+	TOOBIG     = 18 /* String or BLOB exceeds size limit */
+	CONSTRAINT = 19 /* Abort due to constraint violation */
+	MISMATCH   = 20 /* Data type mismatch */
+	MISUSE     = 21 /* Library used incorrectly */
+	NOLFS      = 22 /* Uses OS features not supported on host */
+	AUTH       = 23 /* Authorization denied */
+	FORMAT     = 24 /* Not used */
+	RANGE      = 25 /* 2nd parameter to sqlite3_bind out of range */
+	NOTADB     = 26 /* File opened that is not a database file */
+	NOTICE     = 27 /* Notifications from sqlite3_log() */
+	WARNING    = 28 /* Warnings from sqlite3_log() */
+
+	ROW  = 100 /* sqlite3_step() has another row ready */
+	DONE = 101 /* sqlite3_step() has finished executing */
+
+	ERROR_MISSING_COLLSEQ   = ERROR | (1 << 8)
+	ERROR_RETRY             = ERROR | (2 << 8)
+	ERROR_SNAPSHOT          = ERROR | (3 << 8)
+	ERROR_RESERVESIZE       = ERROR | (4 << 8)
+	ERROR_KEY               = ERROR | (5 << 8)
+	ERROR_UNABLE            = ERROR | (6 << 8)
+	IOERR_READ              = IOERR | (1 << 8)
+	IOERR_SHORT_READ        = IOERR | (2 << 8)
+	IOERR_WRITE             = IOERR | (3 << 8)
+	IOERR_FSYNC             = IOERR | (4 << 8)
+	IOERR_DIR_FSYNC         = IOERR | (5 << 8)
+	IOERR_TRUNCATE          = IOERR | (6 << 8)
+	IOERR_FSTAT             = IOERR | (7 << 8)
+	IOERR_UNLOCK            = IOERR | (8 << 8)
+	IOERR_RDLOCK            = IOERR | (9 << 8)
+	IOERR_DELETE            = IOERR | (10 << 8)
+	IOERR_BLOCKED           = IOERR | (11 << 8)
+	IOERR_NOMEM             = IOERR | (12 << 8)
+	IOERR_ACCESS            = IOERR | (13 << 8)
+	IOERR_CHECKRESERVEDLOCK = IOERR | (14 << 8)
+	IOERR_LOCK              = IOERR | (15 << 8)
+	IOERR_CLOSE             = IOERR | (16 << 8)
+	IOERR_DIR_CLOSE         = IOERR | (17 << 8)
+	IOERR_SHMOPEN           = IOERR | (18 << 8)
+	IOERR_SHMSIZE           = IOERR | (19 << 8)
+	IOERR_SHMLOCK           = IOERR | (20 << 8)
+	IOERR_SHMMAP            = IOERR | (21 << 8)
+	IOERR_SEEK              = IOERR | (22 << 8)
+	IOERR_DELETE_NOENT      = IOERR | (23 << 8)
+	IOERR_MMAP              = IOERR | (24 << 8)
+	IOERR_GETTEMPPATH       = IOERR | (25 << 8)
+	IOERR_CONVPATH          = IOERR | (26 << 8)
+	IOERR_VNODE             = IOERR | (27 << 8)
+	IOERR_AUTH              = IOERR | (28 << 8)
+	IOERR_BEGIN_ATOMIC      = IOERR | (29 << 8)
+	IOERR_COMMIT_ATOMIC     = IOERR | (30 << 8)
+	IOERR_ROLLBACK_ATOMIC   = IOERR | (31 << 8)
+	IOERR_DATA              = IOERR | (32 << 8)
+	IOERR_CORRUPTFS         = IOERR | (33 << 8)
+	IOERR_IN_PAGE           = IOERR | (34 << 8)
+	IOERR_BADKEY            = IOERR | (35 << 8)
+	IOERR_CODEC             = IOERR | (36 << 8)
+	LOCKED_SHAREDCACHE      = LOCKED | (1 << 8)
+	LOCKED_VTAB             = LOCKED | (2 << 8)
+	BUSY_RECOVERY           = BUSY | (1 << 8)
+	BUSY_SNAPSHOT           = BUSY | (2 << 8)
+	BUSY_TIMEOUT            = BUSY | (3 << 8)
+	CANTOPEN_NOTEMPDIR      = CANTOPEN | (1 << 8)
+	CANTOPEN_ISDIR          = CANTOPEN | (2 << 8)
+	CANTOPEN_FULLPATH       = CANTOPEN | (3 << 8)
+	CANTOPEN_CONVPATH       = CANTOPEN | (4 << 8)
+	CANTOPEN_DIRTYWAL       = CANTOPEN | (5 << 8) /* Not Used */
+	CANTOPEN_SYMLINK        = CANTOPEN | (6 << 8)
+	CORRUPT_VTAB            = CORRUPT | (1 << 8)
+	CORRUPT_SEQUENCE        = CORRUPT | (2 << 8)
+	CORRUPT_INDEX           = CORRUPT | (3 << 8)
+	READONLY_RECOVERY       = READONLY | (1 << 8)
+	READONLY_CANTLOCK       = READONLY | (2 << 8)
+	READONLY_ROLLBACK       = READONLY | (3 << 8)
+	READONLY_DBMOVED        = READONLY | (4 << 8)
+	READONLY_CANTINIT       = READONLY | (5 << 8)
+	READONLY_DIRECTORY      = READONLY | (6 << 8)
+	ABORT_ROLLBACK          = ABORT | (2 << 8)
+	CONSTRAINT_CHECK        = CONSTRAINT | (1 << 8)
+	CONSTRAINT_COMMITHOOK   = CONSTRAINT | (2 << 8)
+	CONSTRAINT_FOREIGNKEY   = CONSTRAINT | (3 << 8)
+	CONSTRAINT_FUNCTION     = CONSTRAINT | (4 << 8)
+	CONSTRAINT_NOTNULL      = CONSTRAINT | (5 << 8)
+	CONSTRAINT_PRIMARYKEY   = CONSTRAINT | (6 << 8)
+	CONSTRAINT_TRIGGER      = CONSTRAINT | (7 << 8)
+	CONSTRAINT_UNIQUE       = CONSTRAINT | (8 << 8)
+	CONSTRAINT_VTAB         = CONSTRAINT | (9 << 8)
+	CONSTRAINT_ROWID        = CONSTRAINT | (10 << 8)
+	CONSTRAINT_PINNED       = CONSTRAINT | (11 << 8)
+	CONSTRAINT_DATATYPE     = CONSTRAINT | (12 << 8)
+	NOTICE_RECOVER_WAL      = NOTICE | (1 << 8)
+	NOTICE_RECOVER_ROLLBACK = NOTICE | (2 << 8)
+	NOTICE_RBU              = NOTICE | (3 << 8)
+	WARNING_AUTOINDEX       = WARNING | (1 << 8)
+	AUTH_USER               = AUTH | (1 << 8)
+
+	OK_LOAD_PERMANENTLY = OK | (1 << 8)
+	OK_SYMLINK          = OK | (2 << 8) /* internal use only */
+)

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

@@ -0,0 +1,77 @@
+package sqlite3_wrap
+
+type errorCode interface {
+	~uint8 | ~uint16 | ~uint32 | ~int32
+}
+
+func ErrorCodeString[T errorCode](rc T) string {
+	switch uint32(rc) {
+	case ABORT_ROLLBACK:
+		return "sqlite3: abort due to ROLLBACK"
+	case ROW:
+		return "sqlite3: another row available"
+	case DONE:
+		return "sqlite3: no more rows available"
+	}
+	switch uint8(rc) {
+	case OK:
+		return "sqlite3: not an error"
+	case ERROR:
+		return "sqlite3: SQL logic error"
+	case INTERNAL:
+		break
+	case PERM:
+		return "sqlite3: access permission denied"
+	case ABORT:
+		return "sqlite3: query aborted"
+	case BUSY:
+		return "sqlite3: database is locked"
+	case LOCKED:
+		return "sqlite3: database table is locked"
+	case NOMEM:
+		return "sqlite3: out of memory"
+	case READONLY:
+		return "sqlite3: attempt to write a readonly database"
+	case INTERRUPT:
+		return "sqlite3: interrupted"
+	case IOERR:
+		return "sqlite3: disk I/O error"
+	case CORRUPT:
+		return "sqlite3: database disk image is malformed"
+	case NOTFOUND:
+		return "sqlite3: unknown operation"
+	case FULL:
+		return "sqlite3: database or disk is full"
+	case CANTOPEN:
+		return "sqlite3: unable to open database file"
+	case PROTOCOL:
+		return "sqlite3: locking protocol"
+	case EMPTY:
+		break
+	case SCHEMA:
+		return "sqlite3: database schema has changed"
+	case TOOBIG:
+		return "sqlite3: string or blob too big"
+	case CONSTRAINT:
+		return "sqlite3: constraint failed"
+	case MISMATCH:
+		return "sqlite3: datatype mismatch"
+	case MISUSE:
+		return "sqlite3: bad parameter or other API misuse"
+	case NOLFS:
+		break
+	case AUTH:
+		return "sqlite3: authorization denied"
+	case FORMAT:
+		break
+	case RANGE:
+		return "sqlite3: column index out of range"
+	case NOTADB:
+		return "sqlite3: file is not a database"
+	case NOTICE:
+		return "sqlite3: notification message"
+	case WARNING:
+		return "sqlite3: warning message"
+	}
+	return "sqlite3: unknown error"
+}

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

@@ -0,0 +1,116 @@
+package sqlite3_wrap
+
+import (
+	"bytes"
+	"encoding/binary"
+	"math"
+
+	"github.com/ncruces/go-sqlite3/internal/errutil"
+)
+
+const (
+	PtrLen = 4
+	IntLen = 4
+)
+
+type (
+	Ptr_t uint32
+	Res_t int32
+)
+
+func (mem *Memory) Bytes(ptr Ptr_t, size int64) []byte {
+	if ptr == 0 {
+		panic(errutil.NilErr)
+	}
+	return mem.Buf[ptr:][:size:size]
+}
+
+func (mem *Memory) Read(ptr Ptr_t) byte {
+	if ptr == 0 {
+		panic(errutil.NilErr)
+	}
+	return mem.Buf[ptr]
+}
+
+func (mem *Memory) Write(ptr Ptr_t, v byte) {
+	if ptr == 0 {
+		panic(errutil.NilErr)
+	}
+	mem.Buf[ptr] = v
+}
+
+func (mem *Memory) Read32(ptr Ptr_t) uint32 {
+	if ptr == 0 {
+		panic(errutil.NilErr)
+	}
+	return binary.LittleEndian.Uint32(mem.Buf[ptr:])
+}
+
+func (mem *Memory) Write32(ptr Ptr_t, v uint32) {
+	if ptr == 0 {
+		panic(errutil.NilErr)
+	}
+	binary.LittleEndian.PutUint32(mem.Buf[ptr:], v)
+}
+
+func (mem *Memory) Read64(ptr Ptr_t) uint64 {
+	if ptr == 0 {
+		panic(errutil.NilErr)
+	}
+	return binary.LittleEndian.Uint64(mem.Buf[ptr:])
+}
+
+func (mem *Memory) Write64(ptr Ptr_t, v uint64) {
+	if ptr == 0 {
+		panic(errutil.NilErr)
+	}
+	binary.LittleEndian.PutUint64(mem.Buf[ptr:], v)
+}
+
+func (mem *Memory) ReadFloat64(ptr Ptr_t) float64 {
+	return math.Float64frombits(mem.Read64(ptr))
+}
+
+func (mem *Memory) WriteFloat64(ptr Ptr_t, v float64) {
+	mem.Write64(ptr, math.Float64bits(v))
+}
+
+func (mem *Memory) ReadBool(ptr Ptr_t) bool {
+	return mem.Read32(ptr) != 0
+}
+
+func (mem *Memory) WriteBool(ptr Ptr_t, v bool) {
+	var i uint32
+	if v {
+		i = 1
+	}
+	mem.Write32(ptr, i)
+}
+
+func (mem *Memory) ReadString(ptr Ptr_t, maxlen int64) string {
+	if ptr == 0 {
+		panic(errutil.NilErr)
+	}
+	if maxlen <= 0 {
+		return ""
+	}
+	buf := mem.Buf[ptr:]
+	if int64(len(buf)-1) > maxlen {
+		buf = buf[:maxlen+1]
+	}
+	if before, _, ok := bytes.Cut(buf, []byte{0}); ok {
+		return string(before)
+	}
+	panic(errutil.NoNulErr)
+}
+
+func (mem *Memory) WriteBytes(ptr Ptr_t, b []byte) {
+	buf := mem.Bytes(ptr, int64(len(b)))
+	copy(buf, b)
+}
+
+func (mem *Memory) WriteString(ptr Ptr_t, s string) {
+	buf := mem.Bytes(ptr, int64(len(s))+1)
+	buf[len(s)] = 0
+	copy(buf, s)
+}

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

@@ -0,0 +1,34 @@
+//go:build !unix && !windows
+
+package sqlite3_wrap
+
+import "math"
+
+type Memory struct {
+	Buf []byte
+	Max int64
+}
+
+func (m *Memory) Slice() *[]byte {
+	return &m.Buf
+}
+
+func (m *Memory) Grow(delta, max int64) int64 {
+	len := int64(len(m.Buf))
+	old := len >> 16
+	if delta == 0 {
+		return old
+	}
+	new := old + delta
+	max = min(max, m.Max, int64(math.MaxInt)>>16)
+	if new > max || new < old {
+		return -1
+	}
+	m.Buf = append(m.Buf, make([]byte, new<<16-len)...)
+	return old
+}
+
+func (m *Memory) Close() error {
+	m.Buf = nil
+	return nil
+}

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

@@ -0,0 +1,87 @@
+//go:build unix
+
+package sqlite3_wrap
+
+import (
+	"math"
+
+	"golang.org/x/sys/unix"
+)
+
+type Memory struct {
+	Buf       []byte
+	Max       int64
+	regions   []*MappedRegion
+	committed int
+}
+
+func (m *Memory) Slice() *[]byte {
+	return &m.Buf
+}
+
+func (m *Memory) Grow(delta, max int64) int64 {
+	if m.Buf == nil {
+		m.allocate(uint64(m.Max) << 16)
+	}
+
+	len := int64(len(m.Buf))
+	old := len >> 16
+	if delta == 0 {
+		return old
+	}
+	new := old + delta
+	max = min(max, m.Max, int64(math.MaxInt)>>16)
+	if new > max || new < old {
+		return -1
+	}
+	m.commit(uint64(new) << 16)
+	return old
+}
+
+func (m *Memory) allocate(max uint64) {
+	// Round up to the page size.
+	rnd := uint64(unix.Getpagesize() - 1)
+	res := (max + rnd) &^ rnd
+
+	if res > math.MaxInt {
+		// This ensures int(res) overflows to a negative value,
+		// and unix.Mmap returns EINVAL.
+		res = math.MaxUint64
+	}
+
+	// Reserve res bytes of address space, to ensure we won't need to move it.
+	// A protected, private, anonymous mapping should not commit memory.
+	b, err := unix.Mmap(-1, 0, int(res), unix.PROT_NONE, unix.MAP_PRIVATE|unix.MAP_ANON)
+	if err != nil {
+		panic(err)
+	}
+	m.Buf = b[:0]
+}
+
+func (m *Memory) commit(size uint64) {
+	com := uint64(m.committed)
+	res := uint64(cap(m.Buf))
+	if com < size && size <= res {
+		// Grow geometrically, round up to the page size.
+		rnd := uint64(unix.Getpagesize() - 1)
+		new := com + com>>3
+		new = min(max(size, new), res)
+		new = (new + rnd) &^ rnd
+
+		// Commit additional memory up to new bytes.
+		err := unix.Mprotect(m.Buf[m.committed:new], unix.PROT_READ|unix.PROT_WRITE)
+		if err != nil {
+			panic(err)
+		}
+		m.committed = int(new)
+	}
+	m.Buf = m.Buf[:size]
+}
+
+func (m *Memory) Close() error {
+	err := unix.Munmap(m.Buf[:cap(m.Buf)])
+	m.Buf = nil
+	m.regions = nil
+	m.committed = 0
+	return err
+}