typenative 0.1.3 → 0.2.0

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

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Nuno Cruces
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/govendor/github.com/ncruces/go-sqlite3/README.md

@@ -0,0 +1,121 @@
+# Go bindings to SQLite using wasm2go
+
+[![Go Reference](https://pkg.go.dev/badge/image)](https://pkg.go.dev/github.com/ncruces/go-sqlite3)
+[![Go Coverage](https://github.com/ncruces/go-sqlite3/wiki/coverage.svg)](https://github.com/ncruces/go-sqlite3/wiki/Test-coverage-report)
+
+Go module `github.com/ncruces/go-sqlite3` is a `cgo`-free [SQLite](https://sqlite.org/) wrapper.\
+It provides a [`database/sql`](https://pkg.go.dev/database/sql) compatible driver,
+as well as direct access to most of the [C SQLite API](https://sqlite.org/cintro.html).
+
+It wraps a [Wasm](https://webassembly.org/) build of SQLite,
+and uses [wasm2go](https://github.com/ncruces/wasm2go) to translate it to Go.\
+Go and [`x/sys`](https://pkg.go.dev/golang.org/x/sys) are the _only_ required dependencies.
+
+### Getting started
+
+Using the [`database/sql`](https://pkg.go.dev/database/sql) driver:
+```go
+
+import "database/sql"
+import _ "github.com/ncruces/go-sqlite3/driver"
+
+var version string
+db, _ := sql.Open("sqlite3", "file:demo.db")
+db.QueryRow(`SELECT sqlite_version()`).Scan(&version)
+```
+
+### Packages
+
+- [`github.com/ncruces/go-sqlite3`](https://pkg.go.dev/github.com/ncruces/go-sqlite3)
+  wraps the [C SQLite API](https://sqlite.org/cintro.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3#example-package)).
+- [`github.com/ncruces/go-sqlite3/driver`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver)
+  provides a [`database/sql`](https://pkg.go.dev/database/sql) driver
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver#example-package)).
+- [`github.com/ncruces/go-sqlite3/vfs`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs)
+  wraps the [C SQLite VFS API](https://sqlite.org/vfs.html) and provides a pure Go implementation.
+- [`github.com/ncruces/go-sqlite3/gormlite`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/gormlite)
+  provides a [GORM](https://gorm.io) driver.
+
+### Advanced features
+
+- [incremental BLOB I/O](https://sqlite.org/c3ref/blob_open.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/blobio#example-package))
+- [nested transactions](https://sqlite.org/lang_savepoint.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver#example-Savepoint))
+- [custom functions](https://sqlite.org/c3ref/create_function.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3#example-Conn.CreateFunction))
+- [virtual tables](https://sqlite.org/vtab.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3#example-CreateModule))
+- [custom VFSes](https://sqlite.org/vfs.html)
+  ([examples](vfs/README.md#custom-vfses))
+- [online backup](https://sqlite.org/backup.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver#Conn))
+- [JSON support](https://sqlite.org/json1.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver#example-package-Json))
+- [math functions](https://sqlite.org/lang_mathfunc.html)
+- [Unicode support](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/unicode)
+- [statistics functions](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/stats)
+- [encryption at rest](vfs/adiantum/README.md)
+- [many extensions](ext/README.md)
+
+### Caveats
+
+This module replaces the SQLite [OS Interface](https://sqlite.org/vfs.html)
+(aka VFS) with a [pure Go](vfs/) implementation,
+which has advantages and disadvantages.
+Read more about the Go VFS design [here](vfs/README.md).
+
+Because each database connection executes within a Wasm sandboxed environment,
+memory usage will be higher than alternatives.
+
+### Testing
+
+This project aims for [high test coverage](https://github.com/ncruces/go-sqlite3/wiki/Test-coverage-report).
+It also benefits greatly from [SQLite's](https://sqlite.org/testing.html) thorough testing.
+
+Every commit is tested on:
+* Linux: amd64, arm64, 386, arm, riscv64, ppc64le, loong64, s390x
+* macOS: amd64, arm64
+* Windows: amd64, arm64
+* BSD:
+  * FreeBSD: amd64, arm64
+  * NetBSD: amd64, arm64
+  * DragonFly BSD: amd64
+  * OpenBSD: amd64
+* illumos: amd64
+* Solaris: amd64
+
+Certain operating system and CPU combinations have some limitations.
+See the [support matrix](https://github.com/ncruces/go-sqlite3/wiki/Support-matrix) for a complete overview.
+
+The Go VFS is tested by running SQLite's
+[mptest](https://github.com/sqlite/sqlite/blob/master/mptest/mptest.c).
+
+### Performance
+
+Performance of the [`database/sql`](https://pkg.go.dev/database/sql) driver is
+[competitive](https://github.com/cvilsmeier/go-sqlite-bench) with alternatives.
+
+The Wasm and VFS layers are also benchmarked by running SQLite's
+[speedtest1](https://github.com/sqlite/sqlite/blob/master/test/speedtest1.c).
+
+### Concurrency
+
+This module behaves similarly to SQLite in [multi-thread](https://sqlite.org/threadsafe.html) mode:
+it is goroutine-safe, provided that no single database connection, or object derived from it,
+is used concurrently by multiple goroutines.
+
+The [`database/sql`](https://pkg.go.dev/database/sql) API is safe to use concurrently,
+according to its documentation.
+
+### FAQ, issues, new features
+
+For questions, please see [Discussions](https://github.com/ncruces/go-sqlite3/discussions/categories/q-a).
+
+Also, post there if you used this driver for something interesting
+([_"Show and tell"_](https://github.com/ncruces/go-sqlite3/discussions/categories/show-and-tell)),
+have an [idea](https://github.com/ncruces/go-sqlite3/discussions/categories/ideas)…
+
+The [Issues](https://github.com/ncruces/go-sqlite3/issues) tracker is for bugs,
+and features we're working on, planning to work on, or asking for help with.

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

@@ -0,0 +1,132 @@
+package sqlite3
+
+// Backup is an handle to an ongoing online backup operation.
+//
+// https://sqlite.org/c3ref/backup.html
+type Backup struct {
+	c      *Conn
+	handle ptr_t
+	otherc ptr_t
+}
+
+// Backup backs up srcDB on the src connection to the "main" database in dstURI.
+//
+// Backup opens the SQLite database file dstURI,
+// and blocks until the entire backup is complete.
+// Use [Conn.BackupInit] for incremental backup.
+//
+// https://sqlite.org/backup.html
+func (src *Conn) Backup(srcDB, dstURI string) error {
+	b, err := src.BackupInit(srcDB, dstURI)
+	if err != nil {
+		return err
+	}
+	defer b.Close()
+	_, err = b.Step(-1)
+	return err
+}
+
+// Restore restores dstDB on the dst connection from the "main" database in srcURI.
+//
+// Restore opens the SQLite database file srcURI,
+// and blocks until the entire restore is complete.
+//
+// https://sqlite.org/backup.html
+func (dst *Conn) Restore(dstDB, srcURI string) error {
+	src, err := dst.openDB(srcURI, OPEN_READONLY|OPEN_URI)
+	if err != nil {
+		return err
+	}
+	b, err := dst.backupInit(dst.handle, dstDB, src, "main")
+	if err != nil {
+		return err
+	}
+	defer b.Close()
+	_, err = b.Step(-1)
+	return err
+}
+
+// BackupInit initializes a backup operation to copy the content of one database into another.
+//
+// BackupInit opens the SQLite database file dstURI,
+// then initializes a backup that copies the contents of srcDB on the src connection
+// to the "main" database in dstURI.
+//
+// https://sqlite.org/c3ref/backup_finish.html#sqlite3backupinit
+func (src *Conn) BackupInit(srcDB, dstURI string) (*Backup, error) {
+	dst, err := src.openDB(dstURI, OPEN_READWRITE|OPEN_CREATE|OPEN_URI)
+	if err != nil {
+		return nil, err
+	}
+	return src.backupInit(dst, "main", src.handle, srcDB)
+}
+
+func (c *Conn) backupInit(dst ptr_t, dstName string, src ptr_t, srcName string) (*Backup, error) {
+	defer c.arena.Mark()()
+	dstPtr := c.arena.String(dstName)
+	srcPtr := c.arena.String(srcName)
+
+	other := dst
+	if c.handle == dst {
+		other = src
+	}
+
+	ptr := ptr_t(c.wrp.Xsqlite3_backup_init(
+		int32(dst), int32(dstPtr),
+		int32(src), int32(srcPtr)))
+	if ptr == 0 {
+		defer c.closeDB(other)
+		rc := res_t(c.wrp.Xsqlite3_errcode(int32(dst)))
+		return nil, c.errorFor(dst, rc)
+	}
+
+	return &Backup{
+		c:      c,
+		otherc: other,
+		handle: ptr,
+	}, nil
+}
+
+// Close finishes a backup operation.
+//
+// It is safe to close a nil, zero or closed Backup.
+//
+// https://sqlite.org/c3ref/backup_finish.html#sqlite3backupfinish
+func (b *Backup) Close() error {
+	if b == nil || b.handle == 0 {
+		return nil
+	}
+
+	rc := res_t(b.c.wrp.Xsqlite3_backup_finish(int32(b.handle)))
+	b.c.closeDB(b.otherc)
+	b.handle = 0
+	return b.c.error(rc)
+}
+
+// Step copies up to nPage pages between the source and destination databases.
+// If nPage is negative, all remaining source pages are copied.
+//
+// https://sqlite.org/c3ref/backup_finish.html#sqlite3backupstep
+func (b *Backup) Step(nPage int) (done bool, err error) {
+	rc := res_t(b.c.wrp.Xsqlite3_backup_step(int32(b.handle), int32(nPage)))
+	if rc == _DONE {
+		return true, nil
+	}
+	return false, b.c.error(rc)
+}
+
+// Remaining returns the number of pages still to be backed up
+// at the conclusion of the most recent [Backup.Step].
+//
+// https://sqlite.org/c3ref/backup_finish.html#sqlite3backupremaining
+func (b *Backup) Remaining() int {
+	return int(b.c.wrp.Xsqlite3_backup_remaining(int32(b.handle)))
+}
+
+// PageCount returns the total number of pages in the source database
+// at the conclusion of the most recent [Backup.Step].
+//
+// https://sqlite.org/c3ref/backup_finish.html#sqlite3backuppagecount
+func (b *Backup) PageCount() int {
+	return int(b.c.wrp.Xsqlite3_backup_pagecount(int32(b.handle)))
+}

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

@@ -0,0 +1,266 @@
+package sqlite3
+
+import (
+	"io"
+
+	"github.com/ncruces/go-sqlite3/internal/errutil"
+)
+
+// ZeroBlob represents a zero-filled, length n BLOB
+// that can be used as an argument to
+// [database/sql.DB.Exec] and similar methods.
+type ZeroBlob int64
+
+// Blob is an handle to an open BLOB.
+//
+// It implements [io.ReadWriteSeeker] for incremental BLOB I/O.
+//
+// https://sqlite.org/c3ref/blob.html
+type Blob struct {
+	c      *Conn
+	bytes  int64
+	offset int64
+	handle ptr_t
+	bufptr ptr_t
+	buflen int64
+}
+
+var _ io.ReadWriteSeeker = &Blob{}
+
+// OpenBlob opens a BLOB for incremental I/O.
+//
+// https://sqlite.org/c3ref/blob_open.html
+func (c *Conn) OpenBlob(db, table, column string, row int64, write bool) (*Blob, error) {
+	if c.interrupt.Err() != nil {
+		return nil, INTERRUPT
+	}
+
+	defer c.arena.Mark()()
+	blobPtr := c.arena.New(ptrlen)
+	dbPtr := c.arena.String(db)
+	tablePtr := c.arena.String(table)
+	columnPtr := c.arena.String(column)
+
+	var flags int32
+	if write {
+		flags = 1
+	}
+
+	rc := res_t(c.wrp.Xsqlite3_blob_open(int32(c.handle),
+		int32(dbPtr), int32(tablePtr), int32(columnPtr),
+		row, flags, int32(blobPtr)))
+
+	if err := c.error(rc); err != nil {
+		return nil, err
+	}
+
+	blob := Blob{c: c}
+	blob.handle = ptr_t(c.wrp.Read32(blobPtr))
+	blob.bytes = int64(c.wrp.Xsqlite3_blob_bytes(int32(blob.handle)))
+	return &blob, nil
+}
+
+// Close closes a BLOB handle.
+//
+// It is safe to close a nil, zero or closed Blob.
+//
+// https://sqlite.org/c3ref/blob_close.html
+func (b *Blob) Close() error {
+	if b == nil || b.handle == 0 {
+		return nil
+	}
+
+	rc := res_t(b.c.wrp.Xsqlite3_blob_close(int32(b.handle)))
+	b.c.wrp.Free(b.bufptr)
+	b.handle = 0
+	return b.c.error(rc)
+}
+
+// Size returns the size of the BLOB in bytes.
+//
+// https://sqlite.org/c3ref/blob_bytes.html
+func (b *Blob) Size() int64 {
+	return b.bytes
+}
+
+// Read implements the [io.Reader] interface.
+//
+// https://sqlite.org/c3ref/blob_read.html
+func (b *Blob) Read(p []byte) (n int, err error) {
+	if b.offset >= b.bytes {
+		return 0, io.EOF
+	}
+
+	want := int64(len(p))
+	avail := b.bytes - b.offset
+	if want > avail {
+		want = avail
+	}
+	if want > b.buflen {
+		b.bufptr = b.c.wrp.Realloc(b.bufptr, want)
+		b.buflen = want
+	}
+
+	rc := res_t(b.c.wrp.Xsqlite3_blob_read(int32(b.handle),
+		int32(b.bufptr), int32(want), int32(b.offset)))
+	err = b.c.error(rc)
+	if err != nil {
+		return 0, err
+	}
+	b.offset += want
+	if b.offset >= b.bytes {
+		err = io.EOF
+	}
+
+	copy(p, b.c.wrp.Bytes(b.bufptr, want))
+	return int(want), err
+}
+
+// WriteTo implements the [io.WriterTo] interface.
+//
+// https://sqlite.org/c3ref/blob_read.html
+func (b *Blob) WriteTo(w io.Writer) (n int64, err error) {
+	if b.offset >= b.bytes {
+		return 0, nil
+	}
+
+	want := int64(1024 * 1024)
+	avail := b.bytes - b.offset
+	if want > avail {
+		want = avail
+	}
+	if want > b.buflen {
+		b.bufptr = b.c.wrp.Realloc(b.bufptr, want)
+		b.buflen = want
+	}
+
+	for want > 0 {
+		rc := res_t(b.c.wrp.Xsqlite3_blob_read(int32(b.handle),
+			int32(b.bufptr), int32(want), int32(b.offset)))
+		err = b.c.error(rc)
+		if err != nil {
+			return n, err
+		}
+
+		mem := b.c.wrp.Bytes(b.bufptr, want)
+		m, err := w.Write(mem[:want])
+		b.offset += int64(m)
+		n += int64(m)
+		if err != nil {
+			return n, err
+		}
+		if int64(m) != want {
+			// notest // Write misbehaving
+			return n, io.ErrShortWrite
+		}
+
+		avail = b.bytes - b.offset
+		if want > avail {
+			want = avail
+		}
+	}
+	return n, nil
+}
+
+// Write implements the [io.Writer] interface.
+//
+// https://sqlite.org/c3ref/blob_write.html
+func (b *Blob) Write(p []byte) (n int, err error) {
+	want := int64(len(p))
+	if want > b.buflen {
+		b.bufptr = b.c.wrp.Realloc(b.bufptr, want)
+		b.buflen = want
+	}
+	b.c.wrp.WriteBytes(b.bufptr, p)
+
+	rc := res_t(b.c.wrp.Xsqlite3_blob_write(int32(b.handle),
+		int32(b.bufptr), int32(want), int32(b.offset)))
+	err = b.c.error(rc)
+	if err != nil {
+		return 0, err
+	}
+	b.offset += int64(len(p))
+	return len(p), nil
+}
+
+// ReadFrom implements the [io.ReaderFrom] interface.
+//
+// https://sqlite.org/c3ref/blob_write.html
+func (b *Blob) ReadFrom(r io.Reader) (n int64, err error) {
+	want := int64(1024 * 1024)
+	avail := b.bytes - b.offset
+	if l, ok := r.(*io.LimitedReader); ok && want > l.N {
+		want = l.N
+	}
+	if want > avail {
+		want = avail
+	}
+	if want < 1 {
+		want = 1
+	}
+	if want > b.buflen {
+		b.bufptr = b.c.wrp.Realloc(b.bufptr, want)
+		b.buflen = want
+	}
+
+	for {
+		mem := b.c.wrp.Bytes(b.bufptr, want)
+		m, err := r.Read(mem[:want])
+		if m > 0 {
+			rc := res_t(b.c.wrp.Xsqlite3_blob_write(int32(b.handle),
+				int32(b.bufptr), int32(m), int32(b.offset)))
+			err := b.c.error(rc)
+			if err != nil {
+				return n, err
+			}
+			b.offset += int64(m)
+			n += int64(m)
+		}
+		if err == io.EOF {
+			return n, nil
+		}
+		if err != nil {
+			return n, err
+		}
+
+		avail = b.bytes - b.offset
+		if want > avail {
+			want = avail
+		}
+		if want < 1 {
+			want = 1
+		}
+	}
+}
+
+// Seek implements the [io.Seeker] interface.
+func (b *Blob) Seek(offset int64, whence int) (int64, error) {
+	switch whence {
+	default:
+		return 0, errutil.WhenceErr
+	case io.SeekStart:
+		break
+	case io.SeekCurrent:
+		offset += b.offset
+	case io.SeekEnd:
+		offset += b.bytes
+	}
+	if offset < 0 {
+		return 0, errutil.OffsetErr
+	}
+	b.offset = offset
+	return offset, nil
+}
+
+// Reopen moves a BLOB handle to a new row of the same database table.
+//
+// https://sqlite.org/c3ref/blob_reopen.html
+func (b *Blob) Reopen(row int64) error {
+	if b.c.interrupt.Err() != nil {
+		return INTERRUPT
+	}
+	err := b.c.error(res_t(b.c.wrp.Xsqlite3_blob_reopen(int32(b.handle), row)))
+	b.bytes = int64(b.c.wrp.Xsqlite3_blob_bytes(int32(b.handle)))
+	b.offset = 0
+	return err
+}