typenative 0.1.2 → 0.2.0

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

@@ -0,0 +1,256 @@
+package vfs
+
+import "github.com/ncruces/go-sqlite3/internal/sqlite3_wrap"
+
+const (
+	_MAX_NAME            = 1e6 // Self-imposed limit for most NUL terminated strings.
+	_MAX_SQL_LENGTH      = 1e9
+	_MAX_PATHNAME        = 1024
+	_DEFAULT_SECTOR_SIZE = 4096
+
+	ptrlen = sqlite3_wrap.PtrLen
+)
+
+type ptr_t = sqlite3_wrap.Ptr_t
+
+// https://sqlite.org/rescode.html
+type _ErrorCode uint32
+
+func (e _ErrorCode) Error() string {
+	return sqlite3_wrap.ErrorCodeString(e)
+}
+
+const (
+	_OK                                 = sqlite3_wrap.OK
+	_ERROR                   _ErrorCode = sqlite3_wrap.ERROR
+	_PERM                    _ErrorCode = sqlite3_wrap.PERM
+	_BUSY                    _ErrorCode = sqlite3_wrap.BUSY
+	_READONLY                _ErrorCode = sqlite3_wrap.READONLY
+	_IOERR                   _ErrorCode = sqlite3_wrap.IOERR
+	_NOTFOUND                _ErrorCode = sqlite3_wrap.NOTFOUND
+	_FULL                    _ErrorCode = sqlite3_wrap.FULL
+	_CANTOPEN                _ErrorCode = sqlite3_wrap.CANTOPEN
+	_IOERR_READ              _ErrorCode = sqlite3_wrap.IOERR_READ
+	_IOERR_SHORT_READ        _ErrorCode = sqlite3_wrap.IOERR_SHORT_READ
+	_IOERR_WRITE             _ErrorCode = sqlite3_wrap.IOERR_WRITE
+	_IOERR_FSYNC             _ErrorCode = sqlite3_wrap.IOERR_FSYNC
+	_IOERR_DIR_FSYNC         _ErrorCode = sqlite3_wrap.IOERR_DIR_FSYNC
+	_IOERR_TRUNCATE          _ErrorCode = sqlite3_wrap.IOERR_TRUNCATE
+	_IOERR_FSTAT             _ErrorCode = sqlite3_wrap.IOERR_FSTAT
+	_IOERR_UNLOCK            _ErrorCode = sqlite3_wrap.IOERR_UNLOCK
+	_IOERR_RDLOCK            _ErrorCode = sqlite3_wrap.IOERR_RDLOCK
+	_IOERR_DELETE            _ErrorCode = sqlite3_wrap.IOERR_DELETE
+	_IOERR_NOMEM             _ErrorCode = sqlite3_wrap.IOERR_NOMEM
+	_IOERR_ACCESS            _ErrorCode = sqlite3_wrap.IOERR_ACCESS
+	_IOERR_CHECKRESERVEDLOCK _ErrorCode = sqlite3_wrap.IOERR_CHECKRESERVEDLOCK
+	_IOERR_LOCK              _ErrorCode = sqlite3_wrap.IOERR_LOCK
+	_IOERR_CLOSE             _ErrorCode = sqlite3_wrap.IOERR_CLOSE
+	_IOERR_SHMOPEN           _ErrorCode = sqlite3_wrap.IOERR_SHMOPEN
+	_IOERR_SHMSIZE           _ErrorCode = sqlite3_wrap.IOERR_SHMSIZE
+	_IOERR_SHMLOCK           _ErrorCode = sqlite3_wrap.IOERR_SHMLOCK
+	_IOERR_SHMMAP            _ErrorCode = sqlite3_wrap.IOERR_SHMMAP
+	_IOERR_SEEK              _ErrorCode = sqlite3_wrap.IOERR_SEEK
+	_IOERR_DELETE_NOENT      _ErrorCode = sqlite3_wrap.IOERR_DELETE_NOENT
+	_IOERR_MMAP              _ErrorCode = sqlite3_wrap.IOERR_MMAP
+	_IOERR_GETTEMPPATH       _ErrorCode = sqlite3_wrap.IOERR_GETTEMPPATH
+	_IOERR_BEGIN_ATOMIC      _ErrorCode = sqlite3_wrap.IOERR_BEGIN_ATOMIC
+	_IOERR_COMMIT_ATOMIC     _ErrorCode = sqlite3_wrap.IOERR_COMMIT_ATOMIC
+	_IOERR_ROLLBACK_ATOMIC   _ErrorCode = sqlite3_wrap.IOERR_ROLLBACK_ATOMIC
+	_IOERR_DATA              _ErrorCode = sqlite3_wrap.IOERR_DATA
+	_IOERR_CORRUPTFS         _ErrorCode = sqlite3_wrap.IOERR_CORRUPTFS
+	_BUSY_SNAPSHOT           _ErrorCode = sqlite3_wrap.BUSY_SNAPSHOT
+	_CANTOPEN_FULLPATH       _ErrorCode = sqlite3_wrap.CANTOPEN_FULLPATH
+	_CANTOPEN_ISDIR          _ErrorCode = sqlite3_wrap.CANTOPEN_ISDIR
+	_READONLY_CANTINIT       _ErrorCode = sqlite3_wrap.READONLY_CANTINIT
+	_READONLY_DIRECTORY      _ErrorCode = sqlite3_wrap.READONLY_DIRECTORY
+	_OK_SYMLINK              _ErrorCode = sqlite3_wrap.OK_SYMLINK
+)
+
+// OpenFlag is a flag for the [VFS] Open method.
+//
+// https://sqlite.org/c3ref/c_open_autoproxy.html
+type OpenFlag uint32
+
+const (
+	OPEN_READONLY      OpenFlag = 0x00000001 /* Ok for sqlite3_open_v2() */
+	OPEN_READWRITE     OpenFlag = 0x00000002 /* Ok for sqlite3_open_v2() */
+	OPEN_CREATE        OpenFlag = 0x00000004 /* Ok for sqlite3_open_v2() */
+	OPEN_DELETEONCLOSE OpenFlag = 0x00000008 /* VFS only */
+	OPEN_EXCLUSIVE     OpenFlag = 0x00000010 /* VFS only */
+	OPEN_AUTOPROXY     OpenFlag = 0x00000020 /* VFS only */
+	OPEN_URI           OpenFlag = 0x00000040 /* Ok for sqlite3_open_v2() */
+	OPEN_MEMORY        OpenFlag = 0x00000080 /* Ok for sqlite3_open_v2() */
+	OPEN_MAIN_DB       OpenFlag = 0x00000100 /* VFS only */
+	OPEN_TEMP_DB       OpenFlag = 0x00000200 /* VFS only */
+	OPEN_TRANSIENT_DB  OpenFlag = 0x00000400 /* VFS only */
+	OPEN_MAIN_JOURNAL  OpenFlag = 0x00000800 /* VFS only */
+	OPEN_TEMP_JOURNAL  OpenFlag = 0x00001000 /* VFS only */
+	OPEN_SUBJOURNAL    OpenFlag = 0x00002000 /* VFS only */
+	OPEN_SUPER_JOURNAL OpenFlag = 0x00004000 /* VFS only */
+	OPEN_NOMUTEX       OpenFlag = 0x00008000 /* Ok for sqlite3_open_v2() */
+	OPEN_FULLMUTEX     OpenFlag = 0x00010000 /* Ok for sqlite3_open_v2() */
+	OPEN_SHAREDCACHE   OpenFlag = 0x00020000 /* Ok for sqlite3_open_v2() */
+	OPEN_PRIVATECACHE  OpenFlag = 0x00040000 /* Ok for sqlite3_open_v2() */
+	OPEN_WAL           OpenFlag = 0x00080000 /* VFS only */
+	OPEN_NOFOLLOW      OpenFlag = 0x01000000 /* Ok for sqlite3_open_v2() */
+	_FLAG_ATOMIC       OpenFlag = 0x10000000
+	_FLAG_KEEP_WAL     OpenFlag = 0x20000000
+	_FLAG_PSOW         OpenFlag = 0x40000000
+	_FLAG_SYNC_DIR     OpenFlag = 0x80000000
+)
+
+// AccessFlag is a flag for the [VFS] Access method.
+//
+// https://sqlite.org/c3ref/c_access_exists.html
+type AccessFlag uint32
+
+const (
+	ACCESS_EXISTS    AccessFlag = 0
+	ACCESS_READWRITE AccessFlag = 1 /* Used by PRAGMA temp_store_directory */
+	ACCESS_READ      AccessFlag = 2 /* Unused */
+)
+
+// SyncFlag is a flag for the [File] Sync method.
+//
+// https://sqlite.org/c3ref/c_sync_dataonly.html
+type SyncFlag uint32
+
+const (
+	SYNC_NORMAL   SyncFlag = 0x00002
+	SYNC_FULL     SyncFlag = 0x00003
+	SYNC_DATAONLY SyncFlag = 0x00010
+)
+
+// LockLevel is a value used with [File] Lock and Unlock methods.
+//
+// https://sqlite.org/c3ref/c_lock_exclusive.html
+type LockLevel uint32
+
+const (
+	// No locks are held on the database.
+	// The database may be neither read nor written.
+	// Any internally cached data is considered suspect and subject to
+	// verification against the database file before being used.
+	// Other processes can read or write the database as their own locking
+	// states permit.
+	// This is the default state.
+	LOCK_NONE LockLevel = 0 /* xUnlock() only */
+
+	// The database may be read but not written.
+	// Any number of processes can hold SHARED locks at the same time,
+	// hence there can be many simultaneous readers.
+	// But no other thread or process is allowed to write to the database file
+	// while one or more SHARED locks are active.
+	LOCK_SHARED LockLevel = 1 /* xLock() or xUnlock() */
+
+	// A RESERVED lock means that the process is planning on writing to the
+	// database file at some point in the future but that it is currently just
+	// reading from the file.
+	// Only a single RESERVED lock may be active at one time,
+	// though multiple SHARED locks can coexist with a single RESERVED lock.
+	// RESERVED differs from PENDING in that new SHARED locks can be acquired
+	// while there is a RESERVED lock.
+	LOCK_RESERVED LockLevel = 2 /* xLock() only */
+
+	// A PENDING lock means that the process holding the lock wants to write to
+	// the database as soon as possible and is just waiting on all current
+	// SHARED locks to clear so that it can get an EXCLUSIVE lock.
+	// No new SHARED locks are permitted against the database if a PENDING lock
+	// is active, though existing SHARED locks are allowed to continue.
+	LOCK_PENDING LockLevel = 3 /* internal use only */
+
+	// An EXCLUSIVE lock is needed in order to write to the database file.
+	// Only one EXCLUSIVE lock is allowed on the file and no other locks of any
+	// kind are allowed to coexist with an EXCLUSIVE lock.
+	// In order to maximize concurrency, SQLite works to minimize the amount of
+	// time that EXCLUSIVE locks are held.
+	LOCK_EXCLUSIVE LockLevel = 4 /* xLock() only */
+)
+
+// DeviceCharacteristic is a flag retuned by the [File] DeviceCharacteristics method.
+//
+// https://sqlite.org/c3ref/c_iocap_atomic.html
+type DeviceCharacteristic uint32
+
+const (
+	IOCAP_ATOMIC                DeviceCharacteristic = 0x00000001
+	IOCAP_ATOMIC512             DeviceCharacteristic = 0x00000002
+	IOCAP_ATOMIC1K              DeviceCharacteristic = 0x00000004
+	IOCAP_ATOMIC2K              DeviceCharacteristic = 0x00000008
+	IOCAP_ATOMIC4K              DeviceCharacteristic = 0x00000010
+	IOCAP_ATOMIC8K              DeviceCharacteristic = 0x00000020
+	IOCAP_ATOMIC16K             DeviceCharacteristic = 0x00000040
+	IOCAP_ATOMIC32K             DeviceCharacteristic = 0x00000080
+	IOCAP_ATOMIC64K             DeviceCharacteristic = 0x00000100
+	IOCAP_SAFE_APPEND           DeviceCharacteristic = 0x00000200
+	IOCAP_SEQUENTIAL            DeviceCharacteristic = 0x00000400
+	IOCAP_UNDELETABLE_WHEN_OPEN DeviceCharacteristic = 0x00000800
+	IOCAP_POWERSAFE_OVERWRITE   DeviceCharacteristic = 0x00001000
+	IOCAP_IMMUTABLE             DeviceCharacteristic = 0x00002000
+	IOCAP_BATCH_ATOMIC          DeviceCharacteristic = 0x00004000
+	IOCAP_SUBPAGE_READ          DeviceCharacteristic = 0x00008000
+)
+
+// https://sqlite.org/c3ref/c_fcntl_begin_atomic_write.html
+type _FcntlOpcode uint32
+
+const (
+	_FCNTL_LOCKSTATE             _FcntlOpcode = 1
+	_FCNTL_GET_LOCKPROXYFILE     _FcntlOpcode = 2
+	_FCNTL_SET_LOCKPROXYFILE     _FcntlOpcode = 3
+	_FCNTL_LAST_ERRNO            _FcntlOpcode = 4
+	_FCNTL_SIZE_HINT             _FcntlOpcode = 5
+	_FCNTL_CHUNK_SIZE            _FcntlOpcode = 6
+	_FCNTL_FILE_POINTER          _FcntlOpcode = 7
+	_FCNTL_SYNC_OMITTED          _FcntlOpcode = 8
+	_FCNTL_WIN32_AV_RETRY        _FcntlOpcode = 9
+	_FCNTL_PERSIST_WAL           _FcntlOpcode = 10
+	_FCNTL_OVERWRITE             _FcntlOpcode = 11
+	_FCNTL_VFSNAME               _FcntlOpcode = 12
+	_FCNTL_POWERSAFE_OVERWRITE   _FcntlOpcode = 13
+	_FCNTL_PRAGMA                _FcntlOpcode = 14
+	_FCNTL_BUSYHANDLER           _FcntlOpcode = 15
+	_FCNTL_TEMPFILENAME          _FcntlOpcode = 16
+	_FCNTL_MMAP_SIZE             _FcntlOpcode = 18
+	_FCNTL_TRACE                 _FcntlOpcode = 19
+	_FCNTL_HAS_MOVED             _FcntlOpcode = 20
+	_FCNTL_SYNC                  _FcntlOpcode = 21
+	_FCNTL_COMMIT_PHASETWO       _FcntlOpcode = 22
+	_FCNTL_WIN32_SET_HANDLE      _FcntlOpcode = 23
+	_FCNTL_WAL_BLOCK             _FcntlOpcode = 24
+	_FCNTL_ZIPVFS                _FcntlOpcode = 25
+	_FCNTL_RBU                   _FcntlOpcode = 26
+	_FCNTL_VFS_POINTER           _FcntlOpcode = 27
+	_FCNTL_JOURNAL_POINTER       _FcntlOpcode = 28
+	_FCNTL_WIN32_GET_HANDLE      _FcntlOpcode = 29
+	_FCNTL_PDB                   _FcntlOpcode = 30
+	_FCNTL_BEGIN_ATOMIC_WRITE    _FcntlOpcode = 31
+	_FCNTL_COMMIT_ATOMIC_WRITE   _FcntlOpcode = 32
+	_FCNTL_ROLLBACK_ATOMIC_WRITE _FcntlOpcode = 33
+	_FCNTL_LOCK_TIMEOUT          _FcntlOpcode = 34
+	_FCNTL_DATA_VERSION          _FcntlOpcode = 35
+	_FCNTL_SIZE_LIMIT            _FcntlOpcode = 36
+	_FCNTL_CKPT_DONE             _FcntlOpcode = 37
+	_FCNTL_RESERVE_BYTES         _FcntlOpcode = 38
+	_FCNTL_CKPT_START            _FcntlOpcode = 39
+	_FCNTL_EXTERNAL_READER       _FcntlOpcode = 40
+	_FCNTL_CKSM_FILE             _FcntlOpcode = 41
+	_FCNTL_RESET_CACHE           _FcntlOpcode = 42
+	_FCNTL_NULL_IO               _FcntlOpcode = 43
+	_FCNTL_BLOCK_ON_CONNECT      _FcntlOpcode = 44
+	_FCNTL_FILESTAT              _FcntlOpcode = 45
+)
+
+// https://sqlite.org/c3ref/c_shm_exclusive.html
+type _ShmFlag uint32
+
+const (
+	_SHM_UNLOCK    _ShmFlag = 1
+	_SHM_LOCK      _ShmFlag = 2
+	_SHM_SHARED    _ShmFlag = 4
+	_SHM_EXCLUSIVE _ShmFlag = 8
+
+	_SHM_NLOCK = 8
+	_SHM_BASE  = (22 + _SHM_NLOCK) * 4
+	_SHM_DMS   = _SHM_BASE + _SHM_NLOCK
+)

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

@@ -0,0 +1,260 @@
+package vfs
+
+import (
+	"errors"
+	"io"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"runtime"
+	"syscall"
+)
+
+type vfsOS struct{}
+
+func (vfsOS) FullPathname(path string) (string, error) {
+	link, err := evalSymlinks(path)
+	if err != nil {
+		return "", err
+	}
+	full, err := filepath.Abs(link)
+	if err == nil && link != path {
+		err = _OK_SYMLINK
+	}
+	return full, err
+}
+
+func evalSymlinks(path string) (string, error) {
+	var file string
+	_, err := os.Lstat(path)
+	if errors.Is(err, fs.ErrNotExist) {
+		path, file = filepath.Split(path)
+	}
+	path, err = filepath.EvalSymlinks(path)
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(path, file), nil
+}
+
+func (vfsOS) Delete(path string, syncDir bool) error {
+	err := os.Remove(path)
+	if errors.Is(err, fs.ErrNotExist) {
+		return sysError{err, _IOERR_DELETE_NOENT}
+	}
+	if err != nil {
+		return err
+	}
+	if isUnix && syncDir {
+		f, err := os.Open(filepath.Dir(path))
+		if err != nil {
+			return nil
+		}
+		defer f.Close()
+		err = osSync(f, 0, SYNC_FULL)
+		if err != nil {
+			return sysError{err, _IOERR_DIR_FSYNC}
+		}
+	}
+	return nil
+}
+
+func (vfsOS) Access(name string, flags AccessFlag) (bool, error) {
+	err := osAccess(name, flags)
+	if flags == ACCESS_EXISTS {
+		if errors.Is(err, fs.ErrNotExist) {
+			return false, nil
+		}
+	} else {
+		if errors.Is(err, fs.ErrPermission) {
+			return false, nil
+		}
+	}
+	return err == nil, err
+}
+
+func (vfsOS) Open(name string, flags OpenFlag) (File, OpenFlag, error) {
+	// notest // OpenFilename is called instead
+	if name == "" {
+		return vfsOS{}.OpenFilename(nil, flags)
+	}
+	return nil, 0, _CANTOPEN
+}
+
+func (vfsOS) OpenFilename(name *Filename, flags OpenFlag) (File, OpenFlag, error) {
+	oflags := _O_NOFOLLOW
+	if flags&OPEN_EXCLUSIVE != 0 {
+		oflags |= os.O_EXCL
+	}
+	if flags&OPEN_CREATE != 0 {
+		oflags |= os.O_CREATE
+	}
+	if flags&OPEN_READONLY != 0 {
+		oflags |= os.O_RDONLY
+	}
+	if flags&OPEN_READWRITE != 0 {
+		oflags |= os.O_RDWR
+	}
+
+	isCreate := flags&(OPEN_CREATE) != 0
+	isJournl := flags&(OPEN_MAIN_JOURNAL|OPEN_SUPER_JOURNAL|OPEN_WAL) != 0
+
+	var err error
+	var f *os.File
+	if name == nil {
+		f, err = osCreateTemp(flags)
+	} else {
+		f, err = os.OpenFile(name.String(), oflags, 0666)
+		if errors.Is(err, syscall.EISDIR) {
+			return nil, flags, sysError{err, _CANTOPEN_ISDIR}
+		}
+		if isCreate && isJournl && errors.Is(err, fs.ErrPermission) &&
+			osAccess(name.String(), ACCESS_EXISTS) != nil {
+			return nil, flags, sysError{err, _READONLY_DIRECTORY}
+		}
+	}
+	if err != nil {
+		return nil, flags, err
+	}
+
+	if modeof := name.URIParameter("modeof"); modeof != "" {
+		if err = osSetMode(f, modeof); err != nil {
+			f.Close()
+			return nil, flags, sysError{err, _IOERR_FSTAT}
+		}
+	}
+
+	file := vfsFile{
+		File:  f,
+		flags: flags | _FLAG_PSOW,
+		mmap:  NewMemoryMapper(f, flags),
+	}
+	if osBatchAtomic(f) {
+		file.flags |= _FLAG_ATOMIC
+	}
+	if isUnix && isCreate && isJournl {
+		file.flags |= _FLAG_SYNC_DIR
+	}
+	if name.String() != "" {
+		file.shm = NewSharedMemory(name.String()+"-shm", flags)
+	}
+	return &file, flags, nil
+}
+
+type vfsFile struct {
+	*os.File
+	shm   SharedMemory
+	mmap  MemoryMapper
+	lock  LockLevel
+	flags OpenFlag
+}
+
+var (
+	// Ensure these interfaces are implemented:
+	_ FileLockState          = &vfsFile{}
+	_ FileHasMoved           = &vfsFile{}
+	_ FileSizeHint           = &vfsFile{}
+	_ FilePersistWAL         = &vfsFile{}
+	_ FilePowersafeOverwrite = &vfsFile{}
+)
+
+func (f *vfsFile) Close() error {
+	if !isUnix && f.flags&OPEN_DELETEONCLOSE != 0 {
+		defer os.Remove(f.Name())
+	}
+	if f.shm != nil {
+		f.shm.Close()
+	}
+	f.Unlock(LOCK_NONE)
+	return f.File.Close()
+}
+
+func (f *vfsFile) ReadAt(p []byte, off int64) (n int, err error) {
+	return osReadAt(f.File, p, off)
+}
+
+func (f *vfsFile) WriteAt(p []byte, off int64) (n int, err error) {
+	return osWriteAt(f.File, p, off)
+}
+
+func (f *vfsFile) Sync(flags SyncFlag) error {
+	err := osSync(f.File, f.flags, flags)
+	if err != nil {
+		return err
+	}
+	if isUnix && f.flags&_FLAG_SYNC_DIR != 0 {
+		f.flags ^= _FLAG_SYNC_DIR
+		d, err := os.Open(filepath.Dir(f.File.Name()))
+		if err != nil {
+			return nil
+		}
+		defer d.Close()
+		err = osSync(f.File, f.flags, flags)
+		if err != nil {
+			return sysError{err, _IOERR_DIR_FSYNC}
+		}
+	}
+	return nil
+}
+
+func (f *vfsFile) Size() (int64, error) {
+	return f.Seek(0, io.SeekEnd)
+}
+
+func (f *vfsFile) SectorSize() int {
+	return _DEFAULT_SECTOR_SIZE
+}
+
+func (f *vfsFile) DeviceCharacteristics() DeviceCharacteristic {
+	ret := IOCAP_SUBPAGE_READ
+	if f.flags&_FLAG_ATOMIC != 0 {
+		ret |= IOCAP_BATCH_ATOMIC
+	}
+	if f.flags&_FLAG_PSOW != 0 {
+		ret |= IOCAP_POWERSAFE_OVERWRITE
+	}
+	if runtime.GOOS == "windows" {
+		ret |= IOCAP_UNDELETABLE_WHEN_OPEN
+	}
+	return ret
+}
+
+func (f *vfsFile) SizeHint(size int64) error {
+	return osAllocate(f.File, size)
+}
+
+func (f *vfsFile) HasMoved() (bool, error) {
+	if runtime.GOOS == "windows" {
+		return false, nil
+	}
+	fi, err := f.Stat()
+	if err != nil {
+		return false, err
+	}
+	pi, err := os.Stat(f.Name())
+	if errors.Is(err, fs.ErrNotExist) {
+		return true, nil
+	}
+	if err != nil {
+		return false, err
+	}
+	return !os.SameFile(fi, pi), nil
+}
+
+func (f *vfsFile) LockState() LockLevel     { return f.lock }
+func (f *vfsFile) PowersafeOverwrite() bool { return f.flags&_FLAG_PSOW != 0 }
+func (f *vfsFile) PersistWAL() bool         { return f.flags&_FLAG_KEEP_WAL != 0 }
+
+func (f *vfsFile) SetPowersafeOverwrite(psow bool) {
+	f.flags &^= _FLAG_PSOW
+	if psow {
+		f.flags |= _FLAG_PSOW
+	}
+}
+
+func (f *vfsFile) SetPersistWAL(keepWAL bool) {
+	f.flags &^= _FLAG_KEEP_WAL
+	if keepWAL {
+		f.flags |= _FLAG_KEEP_WAL
+	}
+}

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

@@ -0,0 +1,187 @@
+package vfs
+
+import (
+	"net/url"
+	"strconv"
+
+	"github.com/ncruces/go-sqlite3/internal/sqlite3_wrap"
+	"github.com/ncruces/go-sqlite3/internal/util"
+)
+
+// Filename is used by SQLite to pass filenames
+// to the Open method of a VFS.
+//
+// https://sqlite.org/c3ref/filename.html
+type Filename struct {
+	wrp   *sqlite3_wrap.Wrapper
+	zPath ptr_t
+	flags OpenFlag
+}
+
+// GetFilename is an internal API users should not call directly.
+func GetFilename(wrp *sqlite3_wrap.Wrapper, id ptr_t, flags OpenFlag) *Filename {
+	if id == 0 {
+		return nil
+	}
+	return &Filename{
+		wrp:   wrp,
+		zPath: id,
+		flags: flags,
+	}
+}
+
+// String returns this filename as a string.
+func (n *Filename) String() string {
+	if n == nil || n.zPath == 0 {
+		return ""
+	}
+	return n.wrp.ReadString(n.zPath, _MAX_PATHNAME)
+}
+
+// Database returns the name of the corresponding database file.
+//
+// https://sqlite.org/c3ref/filename_database.html
+func (n *Filename) Database() string {
+	if n == nil || n.zPath == 0 {
+		return ""
+	}
+	return n.path(n.wrp.Xsqlite3_filename_database)
+}
+
+// Journal returns the name of the corresponding rollback journal file.
+//
+// https://sqlite.org/c3ref/filename_database.html
+func (n *Filename) Journal() string {
+	if n == nil || n.zPath == 0 {
+		return ""
+	}
+	return n.path(n.wrp.Xsqlite3_filename_journal)
+}
+
+// WAL returns the name of the corresponding WAL file.
+//
+// https://sqlite.org/c3ref/filename_database.html
+func (n *Filename) WAL() string {
+	if n == nil || n.zPath == 0 {
+		return ""
+	}
+	return n.path(n.wrp.Xsqlite3_filename_wal)
+}
+
+func (n *Filename) path(fn func(int32) int32) string {
+	if n.flags&(OPEN_MAIN_DB|OPEN_MAIN_JOURNAL|OPEN_WAL) == 0 {
+		return ""
+	}
+	name := ptr_t(fn(int32(n.zPath)))
+	return n.wrp.ReadString(name, _MAX_PATHNAME)
+}
+
+// DatabaseFile returns the main database [File] corresponding to a journal.
+//
+// https://sqlite.org/c3ref/database_file_object.html
+func (n *Filename) DatabaseFile() File {
+	if n == nil || n.zPath == 0 {
+		return nil
+	}
+	if n.flags&(OPEN_MAIN_DB|OPEN_MAIN_JOURNAL|OPEN_WAL) == 0 {
+		return nil
+	}
+
+	pFile := ptr_t(n.wrp.Xsqlite3_database_file_object(int32(n.zPath)))
+	file, _ := vfsFileGet(n.wrp, ptr_t(pFile)).(File)
+	return file
+}
+
+// URIParameter returns the value of a URI parameter.
+//
+// https://sqlite.org/c3ref/uri_boolean.html
+func (n *Filename) URIParameter(key string) string {
+	if n == nil || n.zPath == 0 {
+		return ""
+	}
+
+	ptr := ptr_t(n.wrp.Xsqlite3_uri_key(int32(n.zPath), 0))
+	if ptr == 0 {
+		return ""
+	}
+
+	// Parse the format from:
+	// https://github.com/sqlite/sqlite/blob/41fda52/src/pager.c#L4821-L4864
+	// This avoids having to alloc/free the key just to find a value.
+	mem := n.wrp.Memory
+	for {
+		k := mem.ReadString(ptr, _MAX_NAME)
+		if k == "" {
+			return ""
+		}
+		ptr += ptr_t(len(k)) + 1
+
+		v := mem.ReadString(ptr, _MAX_NAME)
+		if k == key {
+			return v
+		}
+		ptr += ptr_t(len(v)) + 1
+	}
+}
+
+// URIParameters obtains values for URI parameters.
+//
+// https://sqlite.org/c3ref/uri_boolean.html
+func (n *Filename) URIParameters() url.Values {
+	if n == nil || n.zPath == 0 {
+		return nil
+	}
+
+	ptr := ptr_t(n.wrp.Xsqlite3_uri_key(int32(n.zPath), 0))
+	if ptr == 0 {
+		return nil
+	}
+
+	var params url.Values
+
+	// Parse the format from:
+	// https://github.com/sqlite/sqlite/blob/41fda52/src/pager.c#L4821-L4864
+	// This is the only way to support multiple valued keys.
+	mem := n.wrp.Memory
+	for {
+		k := mem.ReadString(ptr, _MAX_NAME)
+		if k == "" {
+			return params
+		}
+		ptr += ptr_t(len(k)) + 1
+
+		v := mem.ReadString(ptr, _MAX_NAME)
+		if params == nil {
+			params = url.Values{}
+		}
+		params.Add(k, v)
+		ptr += ptr_t(len(v)) + 1
+	}
+}
+
+// URIBoolean returns the value of a URI parameter as a boolean.
+//
+// https://sqlite.org/c3ref/uri_boolean.html
+func (n *Filename) URIBoolean(key string, def bool) bool {
+	b, ok := util.ParseBool(n.URIParameter(key))
+	if ok {
+		return b
+	}
+	return def
+}
+
+// URIInt64 returns the value of a URI parameter converted
+// to a 64-bit signed integer.
+//
+// https://sqlite.org/c3ref/uri_boolean.html
+func (n *Filename) URIInt64(key string, def int64) int64 {
+	s := n.URIParameter(key)
+	if s == "" {
+		return def
+	}
+	i, err := strconv.ParseInt(s, 10, 64)
+	if err != nil {
+		return def
+	}
+	return i
+}