typenative 0.1.3 → 0.3.0

package/govendor/github.com/ncruces/go-sqlite3/vfs/os_linux.go

@@ -0,0 +1,117 @@
+//go:build !sqlite3_flock
+
+package vfs
+
+import (
+	"io"
+	"os"
+	"path/filepath"
+	"time"
+
+	"golang.org/x/sys/unix"
+)
+
+func osCreateTemp(flags OpenFlag) (*os.File, error) {
+	dir := os.Getenv("SQLITE_TMPDIR")
+	if dir == "" {
+		dir = os.TempDir()
+	}
+
+	for {
+		fd, err := unix.Open(dir, unix.O_RDWR|unix.O_EXCL|unix.O_TMPFILE|unix.O_CLOEXEC, 0600)
+		if err == nil {
+			path := filepath.Join(dir, "tmp.db")
+			return os.NewFile(uintptr(fd), path), nil
+		}
+		if err == unix.EISDIR || err == unix.EOPNOTSUPP {
+			break
+		}
+		if err != unix.EINTR {
+			return nil, sysError{err, _IOERR_GETTEMPPATH}
+		}
+	}
+
+	f, err := os.CreateTemp(dir, "*.db")
+	if err != nil {
+		return nil, sysError{err, _IOERR_GETTEMPPATH}
+	}
+	if flags&OPEN_DELETEONCLOSE != 0 {
+		os.Remove(f.Name())
+	}
+	return f, nil
+}
+
+func osSync(file *os.File, _ OpenFlag, _ SyncFlag) error {
+	// SQLite trusts Linux's fdatasync for all fsync's.
+	for {
+		err := unix.Fdatasync(int(file.Fd()))
+		if err != unix.EINTR {
+			return err
+		}
+	}
+}
+
+func osAllocate(file *os.File, size int64) error {
+	if size == 0 {
+		return nil
+	}
+	end, err := file.Seek(0, io.SeekEnd)
+	if err != nil {
+		return err
+	}
+	if end >= size {
+		return nil
+	}
+
+	for {
+		err := unix.Fallocate(int(file.Fd()), 0, end, size-end)
+		if err == unix.EOPNOTSUPP {
+			break
+		}
+		if err != unix.EINTR {
+			return err
+		}
+	}
+	return file.Truncate(size)
+}
+
+func osReadLock(file *os.File, start, len int64, timeout time.Duration) error {
+	return osLock(file, unix.F_RDLCK, start, len, timeout, _IOERR_RDLOCK)
+}
+
+func osWriteLock(file *os.File, start, len int64, timeout time.Duration) error {
+	return osLock(file, unix.F_WRLCK, start, len, timeout, _IOERR_LOCK)
+}
+
+func osLock(file *os.File, typ int16, start, len int64, timeout time.Duration, def _ErrorCode) error {
+	lock := unix.Flock_t{
+		Type:  typ,
+		Start: start,
+		Len:   len,
+	}
+	var err error
+	switch {
+	default:
+		err = unix.FcntlFlock(file.Fd(), unix.F_OFD_SETLK, &lock)
+	case timeout < 0:
+		err = unix.FcntlFlock(file.Fd(), unix.F_OFD_SETLKW, &lock)
+	}
+	return osLockErrorCode(err, def)
+}
+
+func osUnlock(file *os.File, start, len int64) error {
+	lock := unix.Flock_t{
+		Type:  unix.F_UNLCK,
+		Start: start,
+		Len:   len,
+	}
+	for {
+		err := unix.FcntlFlock(file.Fd(), unix.F_OFD_SETLK, &lock)
+		if err == nil {
+			return nil
+		}
+		if err != unix.EINTR {
+			return sysError{err, _IOERR_UNLOCK}
+		}
+	}
+}

package/govendor/github.com/ncruces/go-sqlite3/vfs/os_ofd.go

@@ -0,0 +1,59 @@
+//go:build (linux || darwin) && !(sqlite3_flock || sqlite3_dotlk)
+
+package vfs
+
+import (
+	"os"
+	"time"
+
+	"golang.org/x/sys/unix"
+)
+
+func osGetSharedLock(file *os.File) error {
+	// Test the PENDING lock before acquiring a new SHARED lock.
+	if lock, _ := osTestLock(file, _PENDING_BYTE, 1, _IOERR); lock == unix.F_WRLCK {
+		return _BUSY
+	}
+	// Acquire the SHARED lock.
+	return osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, 0)
+}
+
+func osGetReservedLock(file *os.File) error {
+	// Acquire the RESERVED lock.
+	return osWriteLock(file, _RESERVED_BYTE, 1, 0)
+}
+
+func osGetExclusiveLock(file *os.File, state *LockLevel) error {
+	if *state == LOCK_RESERVED {
+		// A PENDING lock is needed before acquiring an EXCLUSIVE lock.
+		if err := osWriteLock(file, _PENDING_BYTE, 1, -1); err != nil {
+			return err
+		}
+		*state = LOCK_PENDING
+	}
+	// Acquire the EXCLUSIVE lock.
+	return osWriteLock(file, _SHARED_FIRST, _SHARED_SIZE, time.Millisecond)
+}
+
+func osDowngradeLock(file *os.File, state LockLevel) error {
+	if state >= LOCK_EXCLUSIVE {
+		// Downgrade to a SHARED lock.
+		if err := osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, 0); err != nil {
+			// notest // this should never happen
+			return _IOERR_RDLOCK
+		}
+	}
+	// Release the PENDING and RESERVED locks.
+	return osUnlock(file, _PENDING_BYTE, 2)
+}
+
+func osReleaseLock(file *os.File, _ LockLevel) error {
+	// Release all locks.
+	return osUnlock(file, 0, 0)
+}
+
+func osCheckReservedLock(file *os.File) (bool, error) {
+	// Test the RESERVED lock.
+	lock, err := osTestLock(file, _RESERVED_BYTE, 1, _IOERR_CHECKRESERVEDLOCK)
+	return lock == unix.F_WRLCK, err
+}

package/govendor/github.com/ncruces/go-sqlite3/vfs/os_std.go

@@ -0,0 +1,50 @@
+//go:build !unix
+
+package vfs
+
+import (
+	"io/fs"
+	"os"
+)
+
+const (
+	isUnix      = false
+	_O_NOFOLLOW = 0
+)
+
+func osAccess(path string, flags AccessFlag) error {
+	fi, err := os.Stat(path)
+	if err != nil {
+		return err
+	}
+	if flags == ACCESS_EXISTS {
+		return nil
+	}
+
+	const (
+		S_IREAD  = 0400
+		S_IWRITE = 0200
+		S_IEXEC  = 0100
+	)
+
+	var want fs.FileMode = S_IREAD
+	if flags == ACCESS_READWRITE {
+		want |= S_IWRITE
+	}
+	if fi.IsDir() {
+		want |= S_IEXEC
+	}
+	if fi.Mode()&want != want {
+		return fs.ErrPermission
+	}
+	return nil
+}
+
+func osSetMode(file *os.File, modeof string) error {
+	fi, err := os.Stat(modeof)
+	if err != nil {
+		return err
+	}
+	file.Chmod(fi.Mode())
+	return nil
+}

package/govendor/github.com/ncruces/go-sqlite3/vfs/os_std_alloc.go

@@ -0,0 +1,19 @@
+//go:build !(linux || darwin) || sqlite3_flock
+
+package vfs
+
+import (
+	"io"
+	"os"
+)
+
+func osAllocate(file *os.File, size int64) error {
+	off, err := file.Seek(0, io.SeekEnd)
+	if err != nil {
+		return err
+	}
+	if size <= off {
+		return nil
+	}
+	return file.Truncate(size)
+}

package/govendor/github.com/ncruces/go-sqlite3/vfs/os_std_atomic.go

@@ -0,0 +1,9 @@
+//go:build !linux || !(amd64 || arm64 || riscv64)
+
+package vfs
+
+import "os"
+
+func osBatchAtomic(*os.File) bool {
+	return false
+}

package/govendor/github.com/ncruces/go-sqlite3/vfs/os_std_rw.go

@@ -0,0 +1,13 @@
+//go:build !unix && (!windows || sqlite3_dotlk)
+
+package vfs
+
+import "os"
+
+func osReadAt(file *os.File, p []byte, off int64) (int, error) {
+	return file.ReadAt(p, off)
+}
+
+func osWriteAt(file *os.File, p []byte, off int64) (int, error) {
+	return file.WriteAt(p, off)
+}

package/govendor/github.com/ncruces/go-sqlite3/vfs/os_std_sync.go

@@ -0,0 +1,9 @@
+//go:build !(linux || darwin) || sqlite3_flock
+
+package vfs
+
+import "os"
+
+func osSync(file *os.File, _ OpenFlag, _ SyncFlag) error {
+	return file.Sync()
+}

package/govendor/github.com/ncruces/go-sqlite3/vfs/os_std_temp.go

@@ -0,0 +1,16 @@
+//go:build !linux || sqlite3_flock
+
+package vfs
+
+import "os"
+
+func osCreateTemp(flags OpenFlag) (*os.File, error) {
+	f, err := os.CreateTemp(os.Getenv("SQLITE_TMPDIR"), "*.db")
+	if err != nil {
+		return nil, sysError{err, _IOERR_GETTEMPPATH}
+	}
+	if isUnix && flags&OPEN_DELETEONCLOSE != 0 {
+		os.Remove(f.Name())
+	}
+	return f, nil
+}

package/govendor/github.com/ncruces/go-sqlite3/vfs/os_unix.go

@@ -0,0 +1,108 @@
+//go:build unix
+
+package vfs
+
+import (
+	"os"
+	"syscall"
+
+	"golang.org/x/sys/unix"
+)
+
+const (
+	isUnix      = true
+	_O_NOFOLLOW = unix.O_NOFOLLOW
+)
+
+func osAccess(path string, flags AccessFlag) error {
+	var access uint32 // unix.F_OK
+	switch flags {
+	case ACCESS_READWRITE:
+		access = unix.R_OK | unix.W_OK
+	case ACCESS_READ:
+		access = unix.R_OK
+	}
+	for {
+		err := unix.Access(path, access)
+		if err != unix.EINTR {
+			return err
+		}
+	}
+}
+
+func osReadAt(file *os.File, p []byte, off int64) (int, error) {
+	n, err := file.ReadAt(p, off)
+	if errno, ok := err.(unix.Errno); ok {
+		switch errno {
+		case
+			unix.ERANGE,
+			unix.EIO,
+			unix.ENXIO:
+			return n, sysError{err, _IOERR_CORRUPTFS}
+		}
+	}
+	return n, err
+}
+
+func osWriteAt(file *os.File, p []byte, off int64) (int, error) {
+	n, err := file.WriteAt(p, off)
+	if errno, ok := err.(unix.Errno); ok && errno == unix.ENOSPC {
+		return n, sysError{err, _FULL}
+	}
+	return n, err
+}
+
+func osSetMode(file *os.File, modeof string) error {
+	fi, err := os.Stat(modeof)
+	if err != nil {
+		return err
+	}
+	file.Chmod(fi.Mode())
+	if sys, ok := fi.Sys().(*syscall.Stat_t); ok {
+		file.Chown(int(sys.Uid), int(sys.Gid))
+	}
+	return nil
+}
+
+func osTestLock(file *os.File, start, len int64, def _ErrorCode) (int16, error) {
+	lock := unix.Flock_t{
+		Type:  unix.F_WRLCK,
+		Start: start,
+		Len:   len,
+	}
+	for {
+		err := unix.FcntlFlock(file.Fd(), unix.F_GETLK, &lock)
+		if err == nil {
+			return lock.Type, nil
+		}
+		if err != unix.EINTR {
+			return 0, sysError{err, def}
+		}
+	}
+}
+
+func osLockErrorCode(err error, def _ErrorCode) error {
+	if err == nil {
+		return nil
+	}
+	if errno, ok := err.(unix.Errno); ok {
+		switch errno {
+		case
+			unix.EACCES,
+			unix.EAGAIN,
+			unix.EBUSY,
+			unix.EINTR,
+			unix.ENOLCK,
+			unix.EDEADLK,
+			unix.ETIMEDOUT:
+			return _BUSY
+		case unix.EPERM:
+			return sysError{err, _PERM}
+		}
+		// notest // usually EWOULDBLOCK == EAGAIN
+		if errno == unix.EWOULDBLOCK && unix.EWOULDBLOCK != unix.EAGAIN {
+			return _BUSY
+		}
+	}
+	return sysError{err, def}
+}

package/govendor/github.com/ncruces/go-sqlite3/vfs/os_windows.go

@@ -0,0 +1,180 @@
+//go:build !sqlite3_dotlk
+
+package vfs
+
+import (
+	"os"
+	"time"
+
+	"golang.org/x/sys/windows"
+)
+
+func osReadAt(file *os.File, p []byte, off int64) (int, error) {
+	return file.ReadAt(p, off)
+}
+
+func osWriteAt(file *os.File, p []byte, off int64) (int, error) {
+	n, err := file.WriteAt(p, off)
+	if errno, ok := err.(windows.Errno); ok {
+		switch errno {
+		case
+			windows.ERROR_HANDLE_DISK_FULL,
+			windows.ERROR_DISK_FULL:
+			return n, sysError{err, _FULL}
+		}
+	}
+	return n, err
+}
+
+func osGetSharedLock(file *os.File) error {
+	// Acquire the PENDING lock temporarily before acquiring a new SHARED lock.
+	err := osReadLock(file, _PENDING_BYTE, 1, 0)
+	if err == nil {
+		// Acquire the SHARED lock.
+		err = osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, 0)
+
+		// Release the PENDING lock.
+		osUnlock(file, _PENDING_BYTE, 1)
+	}
+	return err
+}
+
+func osGetReservedLock(file *os.File) error {
+	// Acquire the RESERVED lock.
+	return osWriteLock(file, _RESERVED_BYTE, 1, 0)
+}
+
+func osGetExclusiveLock(file *os.File, state *LockLevel) error {
+	// A PENDING lock is needed before releasing the SHARED lock.
+	if *state < LOCK_PENDING {
+		// If we were RESERVED, we can block indefinitely.
+		var timeout time.Duration
+		if *state == LOCK_RESERVED {
+			timeout = -1
+		}
+		if err := osWriteLock(file, _PENDING_BYTE, 1, timeout); err != nil {
+			return err
+		}
+		*state = LOCK_PENDING
+	}
+
+	// Release the SHARED lock.
+	osUnlock(file, _SHARED_FIRST, _SHARED_SIZE)
+
+	// Acquire the EXCLUSIVE lock.
+	// Can't wait here, because the file is not OVERLAPPED.
+	err := osWriteLock(file, _SHARED_FIRST, _SHARED_SIZE, 0)
+
+	if err != nil {
+		// Reacquire the SHARED lock.
+		if err := osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, 0); err != nil {
+			// notest // this should never happen
+			return _IOERR_RDLOCK
+		}
+	}
+	return err
+}
+
+func osDowngradeLock(file *os.File, state LockLevel) error {
+	if state >= LOCK_EXCLUSIVE {
+		// Release the EXCLUSIVE lock while holding the PENDING lock.
+		osUnlock(file, _SHARED_FIRST, _SHARED_SIZE)
+
+		// Reacquire the SHARED lock.
+		if err := osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, 0); err != nil {
+			// notest // this should never happen
+			return _IOERR_RDLOCK
+		}
+	}
+
+	// Release the PENDING and RESERVED locks.
+	if state >= LOCK_RESERVED {
+		osUnlock(file, _RESERVED_BYTE, 1)
+	}
+	if state >= LOCK_PENDING {
+		osUnlock(file, _PENDING_BYTE, 1)
+	}
+	return nil
+}
+
+func osReleaseLock(file *os.File, state LockLevel) error {
+	// Release all locks, PENDING must be last.
+	if state >= LOCK_RESERVED {
+		osUnlock(file, _RESERVED_BYTE, 1)
+	}
+	if state >= LOCK_SHARED {
+		osUnlock(file, _SHARED_FIRST, _SHARED_SIZE)
+	}
+	if state >= LOCK_PENDING {
+		osUnlock(file, _PENDING_BYTE, 1)
+	}
+	return nil
+}
+
+func osCheckReservedLock(file *os.File) (bool, error) {
+	// Test the RESERVED lock.
+	err := osLock(file, 0, _RESERVED_BYTE, 1, 0, _IOERR_CHECKRESERVEDLOCK)
+	if err == _BUSY {
+		return true, nil
+	}
+	if err == nil {
+		// Release the RESERVED lock.
+		osUnlock(file, _RESERVED_BYTE, 1)
+		return false, nil
+	}
+	return false, err
+}
+
+func osReadLock(file *os.File, start, len uint32, timeout time.Duration) error {
+	return osLock(file, 0, start, len, timeout, _IOERR_RDLOCK)
+}
+
+func osWriteLock(file *os.File, start, len uint32, timeout time.Duration) error {
+	return osLock(file, windows.LOCKFILE_EXCLUSIVE_LOCK, start, len, timeout, _IOERR_LOCK)
+}
+
+func osLock(file *os.File, flags, start, len uint32, timeout time.Duration, def _ErrorCode) error {
+	var err error
+	switch {
+	default:
+		err = osLockEx(file, flags|windows.LOCKFILE_FAIL_IMMEDIATELY, start, len)
+	case timeout < 0:
+		err = osLockEx(file, flags, start, len)
+	}
+	return osLockErrorCode(err, def)
+}
+
+func osUnlock(file *os.File, start, len uint32) error {
+	err := windows.UnlockFileEx(windows.Handle(file.Fd()),
+		0, len, 0, &windows.Overlapped{Offset: start})
+	if err == windows.ERROR_NOT_LOCKED {
+		return nil
+	}
+	if err != nil {
+		return sysError{err, _IOERR_UNLOCK}
+	}
+	return nil
+}
+
+func osLockEx(file *os.File, flags, start, len uint32) error {
+	return windows.LockFileEx(windows.Handle(file.Fd()), flags,
+		0, len, 0, &windows.Overlapped{Offset: start})
+}
+
+func osLockErrorCode(err error, def _ErrorCode) error {
+	if err == nil {
+		return nil
+	}
+	if errno, ok := err.(windows.Errno); ok {
+		// https://devblogs.microsoft.com/oldnewthing/20140905-00/?p=63
+		switch errno {
+		case
+			windows.ERROR_LOCK_VIOLATION,
+			windows.ERROR_OPERATION_ABORTED,
+			windows.ERROR_IO_PENDING,
+			windows.WAIT_TIMEOUT:
+			return _BUSY
+		}
+	}
+	return sysError{err, def}
+}

package/govendor/github.com/ncruces/go-sqlite3/vfs/registry.go

@@ -0,0 +1,48 @@
+package vfs
+
+import "sync"
+
+var (
+	// +checklocks:vfsRegistryMtx
+	vfsRegistry    map[string]VFS
+	vfsRegistryMtx sync.RWMutex
+)
+
+// Find returns a VFS given its name.
+// If there is no match, nil is returned.
+// If name is empty or "os", the default VFS is returned.
+//
+// https://sqlite.org/c3ref/vfs_find.html
+func Find(name string) VFS {
+	if name == "" || name == "os" {
+		return vfsOS{}
+	}
+	vfsRegistryMtx.RLock()
+	defer vfsRegistryMtx.RUnlock()
+	return vfsRegistry[name]
+}
+
+// Register registers a VFS.
+// Empty and "os" are reserved names.
+//
+// https://sqlite.org/c3ref/vfs_find.html
+func Register(name string, vfs VFS) {
+	if name == "" || name == "os" {
+		return
+	}
+	vfsRegistryMtx.Lock()
+	if vfsRegistry == nil {
+		vfsRegistry = map[string]VFS{}
+	}
+	vfsRegistry[name] = vfs
+	vfsRegistryMtx.Unlock()
+}
+
+// Unregister unregisters a VFS.
+//
+// https://sqlite.org/c3ref/vfs_find.html
+func Unregister(name string) {
+	vfsRegistryMtx.Lock()
+	delete(vfsRegistry, name)
+	vfsRegistryMtx.Unlock()
+}

package/govendor/github.com/ncruces/go-sqlite3/vfs/shm.go

@@ -0,0 +1,26 @@
+//go:build linux || darwin || windows || freebsd || openbsd || netbsd || dragonfly || illumos || sqlite3_flock || sqlite3_dotlk
+
+package vfs
+
+// SupportsSharedMemory is false on platforms that do not support shared memory.
+// To use [WAL without shared-memory], you need to set [EXCLUSIVE locking mode].
+//
+// [WAL without shared-memory]: https://sqlite.org/wal.html#noshm
+// [EXCLUSIVE locking mode]: https://sqlite.org/pragma.html#pragma_locking_mode
+const SupportsSharedMemory = true
+
+func (f *vfsFile) SharedMemory() SharedMemory { return f.shm }
+
+// NewSharedMemory returns a shared-memory WAL-index
+// backed by a file with the given path.
+// It will return nil if shared-memory is not supported,
+// or not appropriate for the given flags.
+// Only [OPEN_MAIN_DB] databases may need a WAL-index.
+// You must ensure all concurrent accesses to a database
+// use shared-memory instances created with the same path.
+func NewSharedMemory(path string, flags OpenFlag) SharedMemory {
+	if flags&OPEN_MAIN_DB == 0 || flags&(OPEN_DELETEONCLOSE|OPEN_MEMORY) != 0 {
+		return nil
+	}
+	return &vfsShm{path: path}
+}