Soundex.

Bumps [github.com/tetratelabs/wazero](https://github.com/tetratelabs/wazero) from 1.3.0 to 1.3.1.
- [Release notes](https://github.com/tetratelabs/wazero/releases)
- [Commits](https://github.com/tetratelabs/wazero/compare/v1.3.0...v1.3.1)

---
updated-dependencies:
- dependency-name: github.com/tetratelabs/wazero
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

driver/driver.go

@@ -52,6 +52,11 @@ func (sqlite) Open(name string) (_ driver.Conn, err error) {
 	if err != nil {
 		return nil, err
 	}
+	defer func() {
+		if err != nil {
+			c.Close()
+		}
+	}()
 
 	var pragmas bool
 	c.txBegin = "BEGIN"
@@ -65,7 +70,6 @@ func (sqlite) Open(name string) (_ driver.Conn, err error) {
 			case "deferred", "immediate", "exclusive":
 				c.txBegin = "BEGIN " + s
 			default:
-				c.Close()
 				return nil, fmt.Errorf("sqlite3: invalid _txlock: %s", s)
 			}
 
@@ -73,9 +77,8 @@ func (sqlite) Open(name string) (_ driver.Conn, err error) {
 		}
 	}
 	if !pragmas {
-		err := c.Conn.Exec(`PRAGMA busy_timeout=60000`)
+		err = c.Conn.Exec(`PRAGMA busy_timeout=60000`)
 		if err != nil {
-			c.Close()
 			return nil, err
 		}
 		c.reusable = true
@@ -86,7 +89,6 @@ func (sqlite) Open(name string) (_ driver.Conn, err error) {
 				PRAGMA_query_only;
 		`)
 		if err != nil {
-			c.Close()
 			return nil, err
 		}
 		if s.Step() {
@@ -95,7 +97,6 @@ func (sqlite) Open(name string) (_ driver.Conn, err error) {
 		}
 		err = s.Close()
 		if err != nil {
-			c.Close()
 			return nil, err
 		}
 	}

embed/README.md

@@ -9,6 +9,7 @@ The following optional features are compiled in:
 - [JSON](https://www.sqlite.org/json1.html)
 - [R*Tree](https://www.sqlite.org/rtree.html)
 - [GeoPoly](https://www.sqlite.org/geopoly.html)
+- [soundex](https://www.sqlite.org/lang_corefunc.html#soundex)
 - [base64](https://github.com/sqlite/sqlite/blob/master/ext/misc/base64.c)
 - [decimal](https://github.com/sqlite/sqlite/blob/master/ext/misc/decimal.c)
 - [regexp](https://github.com/sqlite/sqlite/blob/master/ext/misc/regexp.c)

ext/unicode/unicode.go

@@ -0,0 +1,176 @@
+// Package unicode provides an alternative to the SQLite ICU extension.
+//
+// Provides Unicode aware:
+//   - upper and lower functions,
+//   - LIKE and REGEXP operators,
+//   - collation sequences.
+//
+// This package is not 100% compatible with the ICU extension:
+//   - upper and lower use [strings.ToUpper], [strings.ToLower] and [cases];
+//   - the LIKE operator follows [strings.EqualFold] rules;
+//   - the REGEXP operator uses Go [regex/syntax];
+//   - collation sequences use [collate].
+//
+// Expect subtle differences (e.g.) in the handling of Turkish case folding.
+package unicode
+
+import (
+	"bytes"
+	"regexp"
+	"strings"
+	"unicode/utf8"
+
+	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/internal/util"
+	"golang.org/x/text/cases"
+	"golang.org/x/text/collate"
+	"golang.org/x/text/language"
+)
+
+// Register registers Unicode aware functions for a database connection.
+func Register(db *sqlite3.Conn) {
+	flags := sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
+
+	db.CreateFunction("like", 2, flags, like)
+	db.CreateFunction("like", 3, flags, like)
+	db.CreateFunction("upper", 1, flags, upper)
+	db.CreateFunction("upper", 2, flags, upper)
+	db.CreateFunction("lower", 1, flags, lower)
+	db.CreateFunction("lower", 2, flags, lower)
+	db.CreateFunction("regexp", 2, flags, regex)
+	db.CreateFunction("icu_load_collation", 2, sqlite3.DIRECTONLY,
+		func(ctx sqlite3.Context, arg ...sqlite3.Value) {
+			name := arg[1].Text()
+			if name == "" {
+				return
+			}
+
+			tag, err := language.Parse(arg[0].Text())
+			if err != nil {
+				ctx.ResultError(err)
+				return
+			}
+
+			err = db.CreateCollation(name, collate.New(tag).Compare)
+			if err != nil {
+				ctx.ResultError(err)
+				return
+			}
+		})
+}
+
+func upper(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	if len(arg) == 1 {
+		ctx.ResultBlob(bytes.ToUpper(arg[0].RawBlob()))
+		return
+	}
+	cs, ok := ctx.GetAuxData(1).(cases.Caser)
+	if !ok {
+		t, err := language.Parse(arg[1].Text())
+		if err != nil {
+			ctx.ResultError(err)
+			return
+		}
+		c := cases.Upper(t)
+		ctx.SetAuxData(1, c)
+		cs = c
+	}
+	ctx.ResultBlob(cs.Bytes(arg[0].RawBlob()))
+}
+
+func lower(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	if len(arg) == 1 {
+		ctx.ResultBlob(bytes.ToLower(arg[0].RawBlob()))
+		return
+	}
+	cs, ok := ctx.GetAuxData(1).(cases.Caser)
+	if !ok {
+		t, err := language.Parse(arg[1].Text())
+		if err != nil {
+			ctx.ResultError(err)
+			return
+		}
+		c := cases.Lower(t)
+		ctx.SetAuxData(1, c)
+		cs = c
+	}
+	ctx.ResultBlob(cs.Bytes(arg[0].RawBlob()))
+}
+
+func regex(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	re, ok := ctx.GetAuxData(0).(*regexp.Regexp)
+	if !ok {
+		r, err := regexp.Compile(arg[0].Text())
+		if err != nil {
+			ctx.ResultError(err)
+			return
+		}
+		re = r
+		ctx.SetAuxData(0, re)
+	}
+	ctx.ResultBool(re.Match(arg[1].RawBlob()))
+}
+
+func like(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	escape := rune(-1)
+	if len(arg) == 3 {
+		var size int
+		b := arg[2].RawBlob()
+		escape, size = utf8.DecodeRune(b)
+		if size != len(b) {
+			ctx.ResultError(util.ErrorString("ESCAPE expression must be a single character"))
+			return
+		}
+	}
+
+	type likeData struct {
+		*regexp.Regexp
+		escape rune
+	}
+
+	re, ok := ctx.GetAuxData(0).(likeData)
+	if !ok || re.escape != escape {
+		re = likeData{
+			regexp.MustCompile(like2regex(arg[0].Text(), escape)),
+			escape,
+		}
+		ctx.SetAuxData(0, re)
+	}
+	ctx.ResultBool(re.Match(arg[1].RawBlob()))
+}
+
+func like2regex(pattern string, escape rune) string {
+	var re strings.Builder
+	start := 0
+	literal := false
+	re.Grow(len(pattern) + 10)
+	re.WriteString(`(?is)\A`) // case insensitive, . matches any character
+	for i, r := range pattern {
+		if start < 0 {
+			start = i
+		}
+		if literal {
+			literal = false
+			continue
+		}
+		var symbol string
+		switch r {
+		case '_':
+			symbol = `.`
+		case '%':
+			symbol = `.*`
+		case escape:
+			literal = true
+		default:
+			continue
+		}
+		re.WriteString(regexp.QuoteMeta(pattern[start:i]))
+		re.WriteString(symbol)
+		start = -1
+	}
+	if start >= 0 {
+		re.WriteString(regexp.QuoteMeta(pattern[start:]))
+	}
+	re.WriteString(`\z`)
+	return re.String()
+}

ext/unicode/unicode_test.go

@@ -0,0 +1,215 @@
+package unicode
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+
+	"github.com/ncruces/go-sqlite3"
+	_ "github.com/ncruces/go-sqlite3/embed"
+)
+
+func TestRegister(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	exec := func(fn string) string {
+		stmt, _, err := db.Prepare(`SELECT ` + fn)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer stmt.Close()
+
+		if stmt.Step() {
+			return stmt.ColumnText(0)
+		}
+		t.Fatal(stmt.Err())
+		return ""
+	}
+
+	Register(db)
+
+	tests := []struct {
+		test string
+		want string
+	}{
+		{`upper('hello')`, "HELLO"},
+		{`lower('HELLO')`, "hello"},
+		{`upper('привет')`, "ПРИВЕТ"},
+		{`lower('ПРИВЕТ')`, "привет"},
+		{`upper('istanbul')`, "ISTANBUL"},
+		{`upper('istanbul', 'tr-TR')`, "İSTANBUL"},
+		{`lower('Dünyanın İlk Borsası', 'tr-TR')`, "dünyanın ilk borsası"},
+		{`upper('Dünyanın İlk Borsası', 'tr-TR')`, "DÜNYANIN İLK BORSASI"},
+		{`'Hello' REGEXP 'ell'`, "1"},
+		{`'Hello' REGEXP 'el.'`, "1"},
+		{`'Hello' LIKE 'hel_'`, "0"},
+		{`'Hello' LIKE 'hel%'`, "1"},
+		{`'Hello' LIKE 'h_llo'`, "1"},
+		{`'Hello' LIKE 'hello'`, "1"},
+		{`'Привет' LIKE 'ПРИВЕТ'`, "1"},
+		{`'100%' LIKE '100|%' ESCAPE '|'`, "1"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.test, func(t *testing.T) {
+			if got := exec(tt.test); got != tt.want {
+				t.Errorf("exec(%q) = %q, want %q", tt.test, got, tt.want)
+			}
+		})
+	}
+
+	err = db.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestRegister_collation(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	Register(db)
+
+	err = db.Exec(`CREATE TABLE IF NOT EXISTS words (word VARCHAR(10))`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`INSERT INTO words (word) VALUES ('côte'), ('cote'), ('coter'), ('coté'), ('cotée'), ('côté')`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`SELECT icu_load_collation('fr_FR', 'french')`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`SELECT word FROM words ORDER BY word COLLATE french`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer stmt.Close()
+
+	got, want := []string{}, []string{"cote", "coté", "côte", "côté", "cotée", "coter"}
+
+	for stmt.Step() {
+		got = append(got, stmt.ColumnText(0))
+	}
+	if err := stmt.Err(); err != nil {
+		t.Fatal(err)
+	}
+
+	if !reflect.DeepEqual(got, want) {
+		t.Error("not equal")
+	}
+
+	err = stmt.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestRegister_error(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	Register(db)
+
+	err = db.Exec(`SELECT upper('hello', 'enUS')`)
+	if err == nil {
+		t.Error("want error")
+	}
+	if !errors.Is(err, sqlite3.ERROR) {
+		t.Errorf("got %v, want sqlite3.ERROR", err)
+	}
+
+	err = db.Exec(`SELECT lower('hello', 'enUS')`)
+	if err == nil {
+		t.Error("want error")
+	}
+	if !errors.Is(err, sqlite3.ERROR) {
+		t.Errorf("got %v, want sqlite3.ERROR", err)
+	}
+
+	err = db.Exec(`SELECT 'hello' REGEXP '\'`)
+	if err == nil {
+		t.Error("want error")
+	}
+	if !errors.Is(err, sqlite3.ERROR) {
+		t.Errorf("got %v, want sqlite3.ERROR", err)
+	}
+
+	err = db.Exec(`SELECT 'hello' LIKE 'HELLO' ESCAPE '\\'`)
+	if err == nil {
+		t.Error("want error")
+	}
+	if !errors.Is(err, sqlite3.ERROR) {
+		t.Errorf("got %v, want sqlite3.ERROR", err)
+	}
+
+	err = db.Exec(`SELECT icu_load_collation('enUS', 'error')`)
+	if err == nil {
+		t.Error("want error")
+	}
+	if !errors.Is(err, sqlite3.ERROR) {
+		t.Errorf("got %v, want sqlite3.ERROR", err)
+	}
+
+	err = db.Exec(`SELECT icu_load_collation('enUS', '')`)
+	if err != nil {
+		t.Error(err)
+	}
+
+	err = db.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func Test_like2regex(t *testing.T) {
+	const prefix = `(?is)\A`
+	const sufix = `\z`
+	tests := []struct {
+		pattern string
+		escape  rune
+		want    string
+	}{
+		{`a`, -1, `a`},
+		{`a.`, -1, `a\.`},
+		{`a%`, -1, `a.*`},
+		{`a\`, -1, `a\\`},
+		{`a_b`, -1, `a.b`},
+		{`a|b`, '|', `ab`},
+		{`a|_`, '|', `a_`},
+	}
+	for _, tt := range tests {
+		t.Run(tt.pattern, func(t *testing.T) {
+			want := prefix + tt.want + sufix
+			if got := like2regex(tt.pattern, tt.escape); got != want {
+				t.Errorf("like2regex() = %q, want %q", got, want)
+			}
+		})
+	}
+}

func_test.go

@@ -18,6 +18,7 @@ func ExampleConn_CreateCollation() {
 	if err != nil {
 		log.Fatal(err)
 	}
+	defer db.Close()
 
 	err = db.Exec(`CREATE TABLE IF NOT EXISTS words (word VARCHAR(10))`)
 	if err != nil {
@@ -46,16 +47,6 @@ func ExampleConn_CreateCollation() {
 	if err := stmt.Err(); err != nil {
 		log.Fatal(err)
 	}
-
-	err = stmt.Close()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	err = db.Close()
-	if err != nil {
-		log.Fatal(err)
-	}
 	// Output:
 	// cote
 	// coté
@@ -70,6 +61,7 @@ func ExampleConn_CreateFunction() {
 	if err != nil {
 		log.Fatal(err)
 	}
+	defer db.Close()
 
 	err = db.Exec(`CREATE TABLE IF NOT EXISTS words (word VARCHAR(10))`)
 	if err != nil {
@@ -100,16 +92,6 @@ func ExampleConn_CreateFunction() {
 	if err := stmt.Err(); err != nil {
 		log.Fatal(err)
 	}
-
-	err = stmt.Close()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	err = db.Close()
-	if err != nil {
-		log.Fatal(err)
-	}
 	// Unordered output:
 	// COTE
 	// COTÉ
@@ -124,6 +106,7 @@ func ExampleContext_SetAuxData() {
 	if err != nil {
 		log.Fatal(err)
 	}
+	defer db.Close()
 
 	err = db.Exec(`CREATE TABLE IF NOT EXISTS words (word VARCHAR(10))`)
 	if err != nil {
@@ -146,7 +129,7 @@ func ExampleContext_SetAuxData() {
 			ctx.SetAuxData(0, r)
 			re = r
 		}
-		ctx.ResultBool(re.Match(arg[1].RawText()))
+		ctx.ResultBool(re.Match(arg[1].RawBlob()))
 	})
 	if err != nil {
 		log.Fatal(err)
@@ -164,16 +147,6 @@ func ExampleContext_SetAuxData() {
 	if err := stmt.Err(); err != nil {
 		log.Fatal(err)
 	}
-
-	err = stmt.Close()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	err = db.Close()
-	if err != nil {
-		log.Fatal(err)
-	}
 	// Unordered output:
 	// cote
 	// côte

func_win_test.go

@@ -14,6 +14,7 @@ func ExampleConn_CreateWindowFunction() {
 	if err != nil {
 		log.Fatal(err)
 	}
+	defer db.Close()
 
 	err = db.Exec(`CREATE TABLE IF NOT EXISTS words (word VARCHAR(10))`)
 	if err != nil {
@@ -42,16 +43,6 @@ func ExampleConn_CreateWindowFunction() {
 	if err := stmt.Err(); err != nil {
 		log.Fatal(err)
 	}
-
-	err = stmt.Close()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	err = db.Close()
-	if err != nil {
-		log.Fatal(err)
-	}
 	// Output:
 	// 1
 	// 2
@@ -87,7 +78,7 @@ func (f *countASCII) isASCII(arg sqlite3.Value) bool {
 	if arg.Type() != sqlite3.TEXT {
 		return false
 	}
-	for _, c := range arg.RawText() {
+	for _, c := range arg.RawBlob() {
 		if c > unicode.MaxASCII {
 			return false
 		}

go.mod

@@ -5,10 +5,10 @@ go 1.19
 require (
 	github.com/ncruces/julianday v0.1.5
 	github.com/psanford/httpreadat v0.1.0
-	github.com/tetratelabs/wazero v1.2.1
+	github.com/tetratelabs/wazero v1.3.1
 	golang.org/x/sync v0.3.0
 	golang.org/x/sys v0.10.0
-	golang.org/x/text v0.10.0
+	golang.org/x/text v0.11.0
 )
 
 retract v0.4.0 // tagged from the wrong branch

go.sum

@@ -2,11 +2,11 @@ github.com/ncruces/julianday v0.1.5 h1:hDJ9ejiMp3DHsoZ5KW4c1lwfMjbARS7u/gbYcd0FB
 github.com/ncruces/julianday v0.1.5/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g=
 github.com/psanford/httpreadat v0.1.0 h1:VleW1HS2zO7/4c7c7zNl33fO6oYACSagjJIyMIwZLUE=
 github.com/psanford/httpreadat v0.1.0/go.mod h1:Zg7P+TlBm3bYbyHTKv/EdtSJZn3qwbPwpfZ/I9GKCRE=
-github.com/tetratelabs/wazero v1.2.1 h1:J4X2hrGzJvt+wqltuvcSjHQ7ujQxA9gb6PeMs4qlUWs=
-github.com/tetratelabs/wazero v1.2.1/go.mod h1:wYx2gNRg8/WihJfSDxA1TIL8H+GkfLYm+bIfbblu9VQ=
+github.com/tetratelabs/wazero v1.3.1 h1:rnb9FgOEQRLLR8tgoD1mfjNjMhFeWRUk+a4b4j/GpUM=
+github.com/tetratelabs/wazero v1.3.1/go.mod h1:wYx2gNRg8/WihJfSDxA1TIL8H+GkfLYm+bIfbblu9VQ=
 golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E=
 golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
 golang.org/x/sys v0.10.0 h1:SqMFp9UcQJZa+pmYuAKjd9xq1f0j5rLcDIk0mj4qAsA=
 golang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/text v0.10.0 h1:UpjohKhiEgNc0CSauXmwYftY1+LlaC75SJwh0SgCX58=
-golang.org/x/text v0.10.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.11.0 h1:LAntKIrcmeSKERyiOh0XMV39LXS8IE9UL2yP7+f5ij4=
+golang.org/x/text v0.11.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=

gormlite/go.mod

@@ -11,6 +11,6 @@ require (
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/ncruces/julianday v0.1.5 // indirect
-	github.com/tetratelabs/wazero v1.2.1 // indirect
+	github.com/tetratelabs/wazero v1.3.1 // indirect
 	golang.org/x/sys v0.10.0 // indirect
 )

gormlite/go.sum

@@ -6,8 +6,8 @@ github.com/ncruces/go-sqlite3 v0.8.2 h1:U28YYK/Kl5aUsRljcnvShZZHBgWLzuR26zUntP4u
 github.com/ncruces/go-sqlite3 v0.8.2/go.mod h1:yGeN+m3ug1wD/+Kg2A3TnochT6H6Or6+2q8KHN//r9k=
 github.com/ncruces/julianday v0.1.5 h1:hDJ9ejiMp3DHsoZ5KW4c1lwfMjbARS7u/gbYcd0FBZk=
 github.com/ncruces/julianday v0.1.5/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g=
-github.com/tetratelabs/wazero v1.2.1 h1:J4X2hrGzJvt+wqltuvcSjHQ7ujQxA9gb6PeMs4qlUWs=
-github.com/tetratelabs/wazero v1.2.1/go.mod h1:wYx2gNRg8/WihJfSDxA1TIL8H+GkfLYm+bIfbblu9VQ=
+github.com/tetratelabs/wazero v1.3.1 h1:rnb9FgOEQRLLR8tgoD1mfjNjMhFeWRUk+a4b4j/GpUM=
+github.com/tetratelabs/wazero v1.3.1/go.mod h1:wYx2gNRg8/WihJfSDxA1TIL8H+GkfLYm+bIfbblu9VQ=
 golang.org/x/sys v0.10.0 h1:SqMFp9UcQJZa+pmYuAKjd9xq1f0j5rLcDIk0mj4qAsA=
 golang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/text v0.10.0 h1:UpjohKhiEgNc0CSauXmwYftY1+LlaC75SJwh0SgCX58=

internal/util/handle.go

@@ -3,6 +3,8 @@ package util
 import (
 	"context"
 	"io"
+
+	"github.com/tetratelabs/wazero/experimental"
 )
 
 type handleKey struct{}
@@ -11,22 +13,21 @@ type handleState struct {
 	empty   int
 }
 
-func NewContext(ctx context.Context) (context.Context, io.Closer) {
+func NewContext(ctx context.Context) context.Context {
 	state := new(handleState)
-	return context.WithValue(ctx, handleKey{}, state), state
+	ctx = experimental.WithCloseNotifier(ctx, state)
+	ctx = context.WithValue(ctx, handleKey{}, state)
+	return ctx
 }
 
-func (s *handleState) Close() (err error) {
+func (s *handleState) CloseNotify(ctx context.Context, exitCode uint32) {
 	for _, h := range s.handles {
 		if c, ok := h.(io.Closer); ok {
-			if e := c.Close(); err == nil {
-				err = e
-			}
+			c.Close()
 		}
 	}
 	s.handles = nil
 	s.empty = 0
-	return err
 }
 
 func GetHandle(ctx context.Context, id uint32) any {

sqlite.go

@@ -3,7 +3,6 @@ package sqlite3
 
 import (
 	"context"
-	"io"
 	"math"
 	"os"
 	"sync"
@@ -32,23 +31,6 @@ var instance struct {
 	once     sync.Once
 }
 
-func instantiateSQLite() (*sqlite, error) {
-	ctx := context.Background()
-
-	instance.once.Do(compileSQLite)
-	if instance.err != nil {
-		return nil, instance.err
-	}
-
-	cfg := wazero.NewModuleConfig()
-
-	mod, err := instance.runtime.InstantiateModule(ctx, instance.compiled, cfg)
-	if err != nil {
-		return nil, err
-	}
-	return newSQLite(mod)
-}
-
 func compileSQLite() {
 	ctx := context.Background()
 	instance.runtime = wazero.NewRuntime(ctx)
@@ -77,23 +59,32 @@ func compileSQLite() {
 }
 
 type sqlite struct {
-	ctx    context.Context
-	mod    api.Module
-	closer io.Closer
-	api    sqliteAPI
-	stack  [8]uint64
+	ctx   context.Context
+	mod   api.Module
+	api   sqliteAPI
+	stack [8]uint64
 }
 
 type sqliteKey struct{}
 
-func newSQLite(mod api.Module) (sqlt *sqlite, err error) {
+func instantiateSQLite() (sqlt *sqlite, err error) {
+	instance.once.Do(compileSQLite)
+	if instance.err != nil {
+		return nil, instance.err
+	}
+
 	sqlt = new(sqlite)
-	sqlt.ctx, sqlt.closer = util.NewContext(context.Background())
+	sqlt.ctx = util.NewContext(context.Background())
 	sqlt.ctx = context.WithValue(sqlt.ctx, sqliteKey{}, sqlt)
-	sqlt.mod = mod
+
+	sqlt.mod, err = instance.runtime.InstantiateModule(sqlt.ctx,
+		instance.compiled, wazero.NewModuleConfig())
+	if err != nil {
+		return nil, err
+	}
 
 	getFun := func(name string) api.Function {
-		f := mod.ExportedFunction(name)
+		f := sqlt.mod.ExportedFunction(name)
 		if f == nil {
 			err = util.NoFuncErr + util.ErrorString(name)
 			return nil
@@ -102,12 +93,12 @@ func newSQLite(mod api.Module) (sqlt *sqlite, err error) {
 	}
 
 	getVal := func(name string) uint32 {
-		g := mod.ExportedGlobal(name)
+		g := sqlt.mod.ExportedGlobal(name)
 		if g == nil {
 			err = util.NoGlobalErr + util.ErrorString(name)
 			return 0
 		}
-		return util.ReadUint32(mod, uint32(g.Get()))
+		return util.ReadUint32(sqlt.mod, uint32(g.Get()))
 	}
 
 	sqlt.api = sqliteAPI{
@@ -191,9 +182,7 @@ func newSQLite(mod api.Module) (sqlt *sqlite, err error) {
 }
 
 func (sqlt *sqlite) close() error {
-	err := sqlt.mod.Close(sqlt.ctx)
-	sqlt.closer.Close()
-	return err
+	return sqlt.mod.Close(sqlt.ctx)
 }
 
 func (sqlt *sqlite) error(rc uint64, handle uint32, sql ...string) error {
@@ -232,8 +221,6 @@ func (sqlt *sqlite) call(fn api.Function, params ...uint64) uint64 {
 	copy(sqlt.stack[:], params)
 	err := fn.CallWithStack(sqlt.ctx, sqlt.stack[:])
 	if err != nil {
-		// The module closed or panicked; release resources.
-		sqlt.closer.Close()
 		panic(err)
 	}
 	return sqlt.stack[0]

sqlite3/sqlite_cfg.h

@@ -29,6 +29,7 @@
 #define SQLITE_USE_ALLOCA
 
 // Other Options
+
 #define SQLITE_ALLOW_URI_AUTHORITY
 #define SQLITE_ENABLE_BATCH_ATOMIC_WRITE
 #define SQLITE_ENABLE_ATOMIC_WRITE
@@ -55,5 +56,7 @@
 // #define SQLITE_ENABLE_SESSION
 // #define SQLITE_ENABLE_PREUPDATE_HOOK
 
+#define SQLITE_SOUNDEX
+
 // Implemented in vfs.c.
 int localtime_s(struct tm *const pTm, time_t const *const pTime);

vfs/lock_test.go

@@ -41,8 +41,7 @@ func Test_vfsLock(t *testing.T) {
 		pOutput = 32
 	)
 	mod := wazerotest.NewModule(wazerotest.NewMemory(wazerotest.PageSize))
-	ctx, closer := util.NewContext(context.TODO())
-	defer closer.Close()
+	ctx := util.NewContext(context.TODO())
 
 	vfsFileRegister(ctx, mod, pFile1, &vfsFile{File: file1})
 	vfsFileRegister(ctx, mod, pFile2, &vfsFile{File: file2})

vfs/tests/mptest/mptest_test.go

@@ -83,16 +83,15 @@ func system(ctx context.Context, mod api.Module, ptr uint32) uint32 {
 
 	cfg := config(ctx).WithArgs(args...)
 	go func() {
-		ctx, closer := util.NewContext(ctx)
+		ctx := util.NewContext(ctx)
 		mod, _ := rt.InstantiateModule(ctx, module, cfg)
 		mod.Close(ctx)
-		closer.Close()
 	}()
 	return 0
 }
 
 func Test_config01(t *testing.T) {
-	ctx, closer := util.NewContext(newContext(t))
+	ctx := util.NewContext(newContext(t))
 	name := filepath.Join(t.TempDir(), "test.db")
 	cfg := config(ctx).WithArgs("mptest", name, "config01.test")
 	mod, err := rt.InstantiateModule(ctx, module, cfg)
@@ -100,7 +99,6 @@ func Test_config01(t *testing.T) {
 		t.Error(err)
 	}
 	mod.Close(ctx)
-	closer.Close()
 }
 
 func Test_config02(t *testing.T) {
@@ -111,7 +109,7 @@ func Test_config02(t *testing.T) {
 		t.Skip("skipping in CI")
 	}
 
-	ctx, closer := util.NewContext(newContext(t))
+	ctx := util.NewContext(newContext(t))
 	name := filepath.Join(t.TempDir(), "test.db")
 	cfg := config(ctx).WithArgs("mptest", name, "config02.test")
 	mod, err := rt.InstantiateModule(ctx, module, cfg)
@@ -119,7 +117,6 @@ func Test_config02(t *testing.T) {
 		t.Error(err)
 	}
 	mod.Close(ctx)
-	closer.Close()
 }
 
 func Test_crash01(t *testing.T) {
@@ -127,7 +124,7 @@ func Test_crash01(t *testing.T) {
 		t.Skip("skipping in short mode")
 	}
 
-	ctx, closer := util.NewContext(newContext(t))
+	ctx := util.NewContext(newContext(t))
 	name := filepath.Join(t.TempDir(), "test.db")
 	cfg := config(ctx).WithArgs("mptest", name, "crash01.test")
 	mod, err := rt.InstantiateModule(ctx, module, cfg)
@@ -135,7 +132,6 @@ func Test_crash01(t *testing.T) {
 		t.Error(err)
 	}
 	mod.Close(ctx)
-	closer.Close()
 }
 
 func Test_multiwrite01(t *testing.T) {
@@ -143,7 +139,7 @@ func Test_multiwrite01(t *testing.T) {
 		t.Skip("skipping in short mode")
 	}
 
-	ctx, closer := util.NewContext(newContext(t))
+	ctx := util.NewContext(newContext(t))
 	name := filepath.Join(t.TempDir(), "test.db")
 	cfg := config(ctx).WithArgs("mptest", name, "multiwrite01.test")
 	mod, err := rt.InstantiateModule(ctx, module, cfg)
@@ -151,11 +147,10 @@ func Test_multiwrite01(t *testing.T) {
 		t.Error(err)
 	}
 	mod.Close(ctx)
-	closer.Close()
 }
 
 func Test_config01_memory(t *testing.T) {
-	ctx, closer := util.NewContext(newContext(t))
+	ctx := util.NewContext(newContext(t))
 	cfg := config(ctx).WithArgs("mptest", "test.db",
 		"config01.test",
 		"--vfs", "memdb",
@@ -165,7 +160,6 @@ func Test_config01_memory(t *testing.T) {
 		t.Error(err)
 	}
 	mod.Close(ctx)
-	closer.Close()
 }
 
 func Test_multiwrite01_memory(t *testing.T) {
@@ -173,7 +167,7 @@ func Test_multiwrite01_memory(t *testing.T) {
 		t.Skip("skipping in short mode")
 	}
 
-	ctx, closer := util.NewContext(newContext(t))
+	ctx := util.NewContext(newContext(t))
 	cfg := config(ctx).WithArgs("mptest", "/test.db",
 		"multiwrite01.test",
 		"--vfs", "memdb",
@@ -183,7 +177,6 @@ func Test_multiwrite01_memory(t *testing.T) {
 		t.Error(err)
 	}
 	mod.Close(ctx)
-	closer.Close()
 }
 
 func newContext(t *testing.T) context.Context {

vfs/tests/speedtest1/speedtest1_test.go

@@ -75,7 +75,7 @@ func initFlags() {
 
 func Benchmark_speedtest1(b *testing.B) {
 	output.Reset()
-	ctx, closer := util.NewContext(context.Background())
+	ctx := util.NewContext(context.Background())
 	name := filepath.Join(b.TempDir(), "test.db")
 	args := append(options, "--size", strconv.Itoa(b.N), name)
 	cfg := wazero.NewModuleConfig().
@@ -89,5 +89,4 @@ func Benchmark_speedtest1(b *testing.B) {
 		b.Error(err)
 	}
 	mod.Close(ctx)
-	closer.Close()
 }

vfs/vfs_test.go

@@ -220,8 +220,7 @@ func Test_vfsAccess(t *testing.T) {
 
 func Test_vfsFile(t *testing.T) {
 	mod := wazerotest.NewModule(wazerotest.NewMemory(wazerotest.PageSize))
-	ctx, closer := util.NewContext(context.TODO())
-	defer closer.Close()
+	ctx := util.NewContext(context.TODO())
 
 	// Open a temporary file.
 	rc := vfsOpen(ctx, mod, 0, 0, 4, OPEN_CREATE|OPEN_EXCLUSIVE|OPEN_READWRITE|OPEN_DELETEONCLOSE, 0)
@@ -293,8 +292,7 @@ func Test_vfsFile(t *testing.T) {
 
 func Test_vfsFile_psow(t *testing.T) {
 	mod := wazerotest.NewModule(wazerotest.NewMemory(wazerotest.PageSize))
-	ctx, closer := util.NewContext(context.TODO())
-	defer closer.Close()
+	ctx := util.NewContext(context.TODO())
 
 	// Open a temporary file.
 	rc := vfsOpen(ctx, mod, 0, 0, 4, OPEN_CREATE|OPEN_EXCLUSIVE|OPEN_READWRITE|OPEN_DELETEONCLOSE, 0)