Optimize calls.

Bumps [github.com/tetratelabs/wazero](https://github.com/tetratelabs/wazero) from 1.0.3 to 1.1.0.
- [Release notes](https://github.com/tetratelabs/wazero/releases)
- [Commits](https://github.com/tetratelabs/wazero/compare/v1.0.3...v1.1.0)

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

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

blob.go

@@ -86,14 +86,14 @@ func (b *Blob) Read(p []byte) (n int, err error) {
 		return 0, io.EOF
 	}
 
-	want := int64(len(p))
 	avail := b.bytes - b.offset
+	want := int64(len(p))
 	if want > avail {
 		want = avail
 	}
 
-	ptr := b.c.new(uint64(want))
-	defer b.c.free(ptr)
+	defer b.c.arena.reset()
+	ptr := b.c.arena.new(uint64(want))
 
 	r := b.c.call(b.c.api.blobRead, uint64(b.handle),
 		uint64(ptr), uint64(want), uint64(b.offset))
@@ -101,30 +101,68 @@ func (b *Blob) Read(p []byte) (n int, err error) {
 	if err != nil {
 		return 0, err
 	}
-
-	mem := util.View(b.c.mod, ptr, uint64(want))
-	copy(p, mem)
 	b.offset += want
 	if b.offset >= b.bytes {
 		err = io.EOF
 	}
+
+	copy(p, util.View(b.c.mod, ptr, uint64(want)))
 	return int(want), err
 }
 
+// WriteTo implements the [io.WriterTo] interface.
+//
+// https://www.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
+	}
+
+	avail := b.bytes - b.offset
+	want := int64(65536)
+	if want > avail {
+		want = avail
+	}
+
+	ptr := b.c.new(uint64(want))
+	defer b.c.free(ptr)
+
+	for want > 0 {
+		r := b.c.call(b.c.api.blobRead, uint64(b.handle),
+			uint64(ptr), uint64(want), uint64(b.offset))
+		err = b.c.error(r[0])
+		if err != nil {
+			return n, err
+		}
+
+		mem := util.View(b.c.mod, ptr, uint64(want))
+		m, err := w.Write(mem[:want])
+		b.offset += int64(m)
+		n += int64(m)
+		if err != nil {
+			return n, err
+		}
+		if int64(m) != want {
+			return n, io.ErrShortWrite
+		}
+
+		avail = b.bytes - b.offset
+		if want > avail {
+			want = avail
+		}
+	}
+	return n, nil
+}
+
 // Write implements the [io.Writer] interface.
 //
 // https://www.sqlite.org/c3ref/blob_write.html
 func (b *Blob) Write(p []byte) (n int, err error) {
-	offset := b.offset
-	if offset > b.bytes {
-		offset = b.bytes
-	}
-
-	ptr := b.c.newBytes(p)
-	defer b.c.free(ptr)
+	defer b.c.arena.reset()
+	ptr := b.c.arena.bytes(p)
 
 	r := b.c.call(b.c.api.blobWrite, uint64(b.handle),
-		uint64(ptr), uint64(len(p)), uint64(offset))
+		uint64(ptr), uint64(len(p)), uint64(b.offset))
 	err = b.c.error(r[0])
 	if err != nil {
 		return 0, err
@@ -133,6 +171,52 @@ func (b *Blob) Write(p []byte) (n int, err error) {
 	return len(p), nil
 }
 
+// ReadFrom implements the [io.ReaderFrom] interface.
+//
+// https://www.sqlite.org/c3ref/blob_write.html
+func (b *Blob) ReadFrom(r io.Reader) (n int64, err error) {
+	avail := b.bytes - b.offset
+	want := int64(65536)
+	if want > avail {
+		want = avail
+	}
+	if want < 1 {
+		want = 1
+	}
+
+	ptr := b.c.new(uint64(want))
+	defer b.c.free(ptr)
+
+	for {
+		mem := util.View(b.c.mod, ptr, uint64(want))
+		m, err := r.Read(mem[:want])
+		if m > 0 {
+			r := b.c.call(b.c.api.blobWrite, uint64(b.handle),
+				uint64(ptr), uint64(m), uint64(b.offset))
+			err := b.c.error(r[0])
+			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 {
@@ -156,8 +240,8 @@ func (b *Blob) Seek(offset int64, whence int) (int64, error) {
 //
 // https://www.sqlite.org/c3ref/blob_reopen.html
 func (b *Blob) Reopen(row int64) error {
-	r := b.c.call(b.c.api.blobReopen, uint64(b.handle), uint64(row))
+	err := b.c.error(b.c.call(b.c.api.blobReopen, uint64(b.handle), uint64(row))[0])
 	b.bytes = int64(b.c.call(b.c.api.blobBytes, uint64(b.handle))[0])
 	b.offset = 0
-	return b.c.error(r[0])
+	return err
 }

go.mod

@@ -4,7 +4,7 @@ go 1.19
 
 require (
 	github.com/ncruces/julianday v0.1.5
-	github.com/tetratelabs/wazero v1.0.2
+	github.com/tetratelabs/wazero v1.1.0
 	golang.org/x/sync v0.1.0
 	golang.org/x/sys v0.7.0
 )

go.sum

@@ -1,7 +1,7 @@
 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.0.2 h1:lpwL5zczFHk2mxKur98035Gig+Z3vd9JURk6lUdZxXY=
-github.com/tetratelabs/wazero v1.0.2/go.mod h1:wYx2gNRg8/WihJfSDxA1TIL8H+GkfLYm+bIfbblu9VQ=
+github.com/tetratelabs/wazero v1.1.0 h1:EByoAhC+QcYpwSZJSs/aV0uokxPwBgKxfiokSUwAknQ=
+github.com/tetratelabs/wazero v1.1.0/go.mod h1:wYx2gNRg8/WihJfSDxA1TIL8H+GkfLYm+bIfbblu9VQ=
 golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
 golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU=

internal/util/func.go

@@ -1,4 +1,4 @@
-package vfs
+package util
 
 import (
 	"context"
@@ -7,7 +7,10 @@ import (
 	"github.com/tetratelabs/wazero/api"
 )
 
-func registerFunc1[T0, TR ~uint32](mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ T0) TR) {
+type i32 interface{ ~int32 | ~uint32 }
+type i64 interface{ ~int64 | ~uint64 }
+
+func RegisterFuncII[TR, T0 i32](mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ T0) TR) {
 	mod.NewFunctionBuilder().
 		WithGoModuleFunction(api.GoModuleFunc(
 			func(ctx context.Context, mod api.Module, stack []uint64) {
@@ -17,7 +20,7 @@ func registerFunc1[T0, TR ~uint32](mod wazero.HostModuleBuilder, name string, fn
 		Export(name)
 }
 
-func registerFunc2[T0, T1, TR ~uint32](mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ T0, _ T1) TR) {
+func RegisterFuncIII[TR, T0, T1 i32](mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ T0, _ T1) TR) {
 	mod.NewFunctionBuilder().
 		WithGoModuleFunction(api.GoModuleFunc(
 			func(ctx context.Context, mod api.Module, stack []uint64) {
@@ -27,7 +30,7 @@ func registerFunc2[T0, T1, TR ~uint32](mod wazero.HostModuleBuilder, name string
 		Export(name)
 }
 
-func registerFunc3[T0, T1, T2, TR ~uint32](mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ T0, _ T1, _ T2) TR) {
+func RegisterFuncIIII[TR, T0, T1, T2 i32](mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ T0, _ T1, _ T2) TR) {
 	mod.NewFunctionBuilder().
 		WithGoModuleFunction(api.GoModuleFunc(
 			func(ctx context.Context, mod api.Module, stack []uint64) {
@@ -37,7 +40,7 @@ func registerFunc3[T0, T1, T2, TR ~uint32](mod wazero.HostModuleBuilder, name st
 		Export(name)
 }
 
-func registerFunc4[T0, T1, T2, T3, TR ~uint32](mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ T0, _ T1, _ T2, _ T3) TR) {
+func RegisterFuncIIIII[TR, T0, T1, T2, T3 i32](mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ T0, _ T1, _ T2, _ T3) TR) {
 	mod.NewFunctionBuilder().
 		WithGoModuleFunction(api.GoModuleFunc(
 			func(ctx context.Context, mod api.Module, stack []uint64) {
@@ -47,7 +50,7 @@ func registerFunc4[T0, T1, T2, T3, TR ~uint32](mod wazero.HostModuleBuilder, nam
 		Export(name)
 }
 
-func registerFunc5[T0, T1, T2, T3, T4, TR ~uint32](mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ T0, _ T1, _ T2, _ T3, _ T4) TR) {
+func RegisterFuncIIIIII[TR, T0, T1, T2, T3, T4 i32](mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ T0, _ T1, _ T2, _ T3, _ T4) TR) {
 	mod.NewFunctionBuilder().
 		WithGoModuleFunction(api.GoModuleFunc(
 			func(ctx context.Context, mod api.Module, stack []uint64) {
@@ -57,21 +60,21 @@ func registerFunc5[T0, T1, T2, T3, T4, TR ~uint32](mod wazero.HostModuleBuilder,
 		Export(name)
 }
 
-func registerFuncRW(mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _, _, _ uint32, _ int64) _ErrorCode) {
+func RegisterFuncIIIIJ[TR, T0, T1, T2 i32, T3 i64](mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ T0, _ T1, _ T2, _ T3) TR) {
 	mod.NewFunctionBuilder().
 		WithGoModuleFunction(api.GoModuleFunc(
 			func(ctx context.Context, mod api.Module, stack []uint64) {
-				stack[0] = uint64(fn(ctx, mod, uint32(stack[0]), uint32(stack[1]), uint32(stack[2]), int64(stack[3])))
+				stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]), T3(stack[3])))
 			}),
 			[]api.ValueType{api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI64}, []api.ValueType{api.ValueTypeI32}).
 		Export(name)
 }
 
-func registerFuncT(mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ uint32, _ int64) _ErrorCode) {
+func RegisterFuncIIJ[TR, T0 i32, T1 i64](mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ T0, _ T1) TR) {
 	mod.NewFunctionBuilder().
 		WithGoModuleFunction(api.GoModuleFunc(
 			func(ctx context.Context, mod api.Module, stack []uint64) {
-				stack[0] = uint64(fn(ctx, mod, uint32(stack[0]), int64(stack[1])))
+				stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1])))
 			}),
 			[]api.ValueType{api.ValueTypeI32, api.ValueTypeI64}, []api.ValueType{api.ValueTypeI32}).
 		Export(name)

internal/util/mock.go

@@ -1,7 +1,6 @@
 package util
 
 import (
-	"context"
 	"encoding/binary"
 	"math"
 
@@ -9,51 +8,47 @@ import (
 )
 
 func NewMockModule(size uint32) api.Module {
-	mem := make(mockMemory, size)
-	return mockModule{&mem}
+	mem := mockMemory{buf: make([]byte, size)}
+	return mockModule{&mem, nil}
 }
 
 type mockModule struct {
 	memory api.Memory
+	api.Module
 }
 
 func (m mockModule) Memory() api.Memory { return m.memory }
 func (m mockModule) String() string     { return "mockModule" }
 func (m mockModule) Name() string       { return "mockModule" }
 
-func (m mockModule) ExportedGlobal(name string) api.Global                          { return nil }
-func (m mockModule) ExportedMemory(name string) api.Memory                          { return nil }
-func (m mockModule) ExportedFunction(name string) api.Function                      { return nil }
-func (m mockModule) ExportedMemoryDefinitions() map[string]api.MemoryDefinition     { return nil }
-func (m mockModule) ExportedFunctionDefinitions() map[string]api.FunctionDefinition { return nil }
-func (m mockModule) CloseWithExitCode(ctx context.Context, exitCode uint32) error   { return nil }
-func (m mockModule) Close(context.Context) error                                    { return nil }
-
-type mockMemory []byte
+type mockMemory struct {
+	buf []byte
+	api.Memory
+}
 
 func (m mockMemory) Definition() api.MemoryDefinition { return nil }
 
-func (m mockMemory) Size() uint32 { return uint32(len(m)) }
+func (m mockMemory) Size() uint32 { return uint32(len(m.buf)) }
 
 func (m mockMemory) ReadByte(offset uint32) (byte, bool) {
 	if offset >= m.Size() {
 		return 0, false
 	}
-	return m[offset], true
+	return m.buf[offset], true
 }
 
 func (m mockMemory) ReadUint16Le(offset uint32) (uint16, bool) {
 	if !m.hasSize(offset, 2) {
 		return 0, false
 	}
-	return binary.LittleEndian.Uint16(m[offset : offset+2]), true
+	return binary.LittleEndian.Uint16(m.buf[offset : offset+2]), true
 }
 
 func (m mockMemory) ReadUint32Le(offset uint32) (uint32, bool) {
 	if !m.hasSize(offset, 4) {
 		return 0, false
 	}
-	return binary.LittleEndian.Uint32(m[offset : offset+4]), true
+	return binary.LittleEndian.Uint32(m.buf[offset : offset+4]), true
 }
 
 func (m mockMemory) ReadFloat32Le(offset uint32) (float32, bool) {
@@ -68,7 +63,7 @@ func (m mockMemory) ReadUint64Le(offset uint32) (uint64, bool) {
 	if !m.hasSize(offset, 8) {
 		return 0, false
 	}
-	return binary.LittleEndian.Uint64(m[offset : offset+8]), true
+	return binary.LittleEndian.Uint64(m.buf[offset : offset+8]), true
 }
 
 func (m mockMemory) ReadFloat64Le(offset uint32) (float64, bool) {
@@ -83,14 +78,14 @@ func (m mockMemory) Read(offset, byteCount uint32) ([]byte, bool) {
 	if !m.hasSize(offset, byteCount) {
 		return nil, false
 	}
-	return m[offset : offset+byteCount : offset+byteCount], true
+	return m.buf[offset : offset+byteCount : offset+byteCount], true
 }
 
 func (m mockMemory) WriteByte(offset uint32, v byte) bool {
 	if offset >= m.Size() {
 		return false
 	}
-	m[offset] = v
+	m.buf[offset] = v
 	return true
 }
 
@@ -98,7 +93,7 @@ func (m mockMemory) WriteUint16Le(offset uint32, v uint16) bool {
 	if !m.hasSize(offset, 2) {
 		return false
 	}
-	binary.LittleEndian.PutUint16(m[offset:], v)
+	binary.LittleEndian.PutUint16(m.buf[offset:], v)
 	return true
 }
 
@@ -106,7 +101,7 @@ func (m mockMemory) WriteUint32Le(offset, v uint32) bool {
 	if !m.hasSize(offset, 4) {
 		return false
 	}
-	binary.LittleEndian.PutUint32(m[offset:], v)
+	binary.LittleEndian.PutUint32(m.buf[offset:], v)
 	return true
 }
 
@@ -118,7 +113,7 @@ func (m mockMemory) WriteUint64Le(offset uint32, v uint64) bool {
 	if !m.hasSize(offset, 8) {
 		return false
 	}
-	binary.LittleEndian.PutUint64(m[offset:], v)
+	binary.LittleEndian.PutUint64(m.buf[offset:], v)
 	return true
 }
 
@@ -130,7 +125,7 @@ func (m mockMemory) Write(offset uint32, val []byte) bool {
 	if !m.hasSize(offset, uint32(len(val))) {
 		return false
 	}
-	copy(m[offset:], val)
+	copy(m.buf[offset:], val)
 	return true
 }
 
@@ -138,16 +133,16 @@ func (m mockMemory) WriteString(offset uint32, val string) bool {
 	if !m.hasSize(offset, uint32(len(val))) {
 		return false
 	}
-	copy(m[offset:], val)
+	copy(m.buf[offset:], val)
 	return true
 }
 
 func (m *mockMemory) Grow(delta uint32) (result uint32, ok bool) {
-	prev := (len(*m) + 65535) / 65536
-	*m = append(*m, make([]byte, 65536*delta)...)
+	prev := (len(m.buf) + 65535) / 65536
+	m.buf = append(m.buf, make([]byte, 65536*delta)...)
 	return uint32(prev), true
 }
 
 func (m mockMemory) hasSize(offset uint32, byteCount uint32) bool {
-	return uint64(offset)+uint64(byteCount) <= uint64(len(m))
+	return uint64(offset)+uint64(byteCount) <= uint64(len(m.buf))
 }

internal/vfs/tests/mptest/mptest_test.go

@@ -40,7 +40,8 @@ func init() {
 
 	rt = wazero.NewRuntime(ctx)
 	wasi_snapshot_preview1.MustInstantiate(ctx, rt)
-	env := vfs.NewEnvModuleBuilder(rt)
+
+	env := vfs.Export(rt.NewHostModuleBuilder("env"))
 	env.NewFunctionBuilder().WithFunc(system).Export("system")
 	_, err := env.Instantiate(ctx)
 	if err != nil {

internal/vfs/tests/speedtest1/speedtest1_test.go

@@ -35,7 +35,7 @@ func init() {
 
 	rt = wazero.NewRuntime(ctx)
 	wasi_snapshot_preview1.MustInstantiate(ctx, rt)
-	env := vfs.NewEnvModuleBuilder(rt)
+	env := vfs.Export(rt.NewHostModuleBuilder("env"))
 	_, err := env.Instantiate(ctx)
 	if err != nil {
 		panic(err)

internal/vfs/vfs.go

@@ -17,37 +17,28 @@ import (
 	"github.com/tetratelabs/wazero/api"
 )
 
-func Instantiate(ctx context.Context, r wazero.Runtime) {
-	env := NewEnvModuleBuilder(r)
-	_, err := env.Instantiate(ctx)
-	if err != nil {
-		panic(err)
-	}
-}
-
-func NewEnvModuleBuilder(r wazero.Runtime) wazero.HostModuleBuilder {
-	env := r.NewHostModuleBuilder("env")
-	registerFuncT(env, "os_localtime", vfsLocaltime)
-	registerFunc3(env, "os_randomness", vfsRandomness)
-	registerFunc2(env, "os_sleep", vfsSleep)
-	registerFunc2(env, "os_current_time", vfsCurrentTime)
-	registerFunc2(env, "os_current_time_64", vfsCurrentTime64)
-	registerFunc4(env, "os_full_pathname", vfsFullPathname)
-	registerFunc3(env, "os_delete", vfsDelete)
-	registerFunc4(env, "os_access", vfsAccess)
-	registerFunc5(env, "os_open", vfsOpen)
-	registerFunc1(env, "os_close", vfsClose)
-	registerFuncRW(env, "os_read", vfsRead)
-	registerFuncRW(env, "os_write", vfsWrite)
-	registerFuncT(env, "os_truncate", vfsTruncate)
-	registerFunc2(env, "os_sync", vfsSync)
-	registerFunc2(env, "os_file_size", vfsFileSize)
-	registerFunc3(env, "os_file_control", vfsFileControl)
-	registerFunc1(env, "os_sector_size", vfsSectorSize)
-	registerFunc1(env, "os_device_characteristics", vfsDeviceCharacteristics)
-	registerFunc2(env, "os_lock", vfsLock)
-	registerFunc2(env, "os_unlock", vfsUnlock)
-	registerFunc2(env, "os_check_reserved_lock", vfsCheckReservedLock)
+func Export(env wazero.HostModuleBuilder) wazero.HostModuleBuilder {
+	util.RegisterFuncIIJ(env, "os_localtime", vfsLocaltime)
+	util.RegisterFuncIIII(env, "os_randomness", vfsRandomness)
+	util.RegisterFuncIII(env, "os_sleep", vfsSleep)
+	util.RegisterFuncIII(env, "os_current_time", vfsCurrentTime)
+	util.RegisterFuncIII(env, "os_current_time_64", vfsCurrentTime64)
+	util.RegisterFuncIIIII(env, "os_full_pathname", vfsFullPathname)
+	util.RegisterFuncIIII(env, "os_delete", vfsDelete)
+	util.RegisterFuncIIIII(env, "os_access", vfsAccess)
+	util.RegisterFuncIIIIII(env, "os_open", vfsOpen)
+	util.RegisterFuncII(env, "os_close", vfsClose)
+	util.RegisterFuncIIIIJ(env, "os_read", vfsRead)
+	util.RegisterFuncIIIIJ(env, "os_write", vfsWrite)
+	util.RegisterFuncIIJ(env, "os_truncate", vfsTruncate)
+	util.RegisterFuncIII(env, "os_sync", vfsSync)
+	util.RegisterFuncIII(env, "os_file_size", vfsFileSize)
+	util.RegisterFuncIIII(env, "os_file_control", vfsFileControl)
+	util.RegisterFuncII(env, "os_sector_size", vfsSectorSize)
+	util.RegisterFuncII(env, "os_device_characteristics", vfsDeviceCharacteristics)
+	util.RegisterFuncIII(env, "os_lock", vfsLock)
+	util.RegisterFuncIII(env, "os_unlock", vfsUnlock)
+	util.RegisterFuncIII(env, "os_check_reserved_lock", vfsCheckReservedLock)
 	return env
 }
 

module.go

@@ -52,7 +52,12 @@ func instantiateModule() (*module, error) {
 func compileModule() {
 	ctx := context.Background()
 	sqlite3.runtime = wazero.NewRuntime(ctx)
-	vfs.Instantiate(ctx, sqlite3.runtime)
+
+	env := vfs.Export(sqlite3.runtime.NewHostModuleBuilder("env"))
+	_, sqlite3.err = env.Instantiate(ctx)
+	if sqlite3.err != nil {
+		return
+	}
 
 	bin := Binary
 	if bin == nil && Path != "" {
@@ -74,7 +79,7 @@ type module struct {
 	mod api.Module
 	vfs io.Closer
 	api sqliteAPI
-	arg []uint64
+	arg [8]uint64
 }
 
 func newModule(mod api.Module) (m *module, err error) {
@@ -200,14 +205,14 @@ func (m *module) error(rc uint64, handle uint32, sql ...string) error {
 }
 
 func (m *module) call(fn api.Function, params ...uint64) []uint64 {
-	m.arg = append(m.arg[:0], params...)
-	r, err := fn.Call(m.ctx, m.arg...)
+	copy(m.arg[:], params)
+	err := fn.CallWithStack(m.ctx, m.arg[:])
 	if err != nil {
 		// The module closed or panicked; release resources.
 		m.vfs.Close()
 		panic(err)
 	}
-	return r
+	return m.arg[:]
 }
 
 func (m *module) free(ptr uint32) {
@@ -288,6 +293,15 @@ func (a *arena) new(size uint64) uint32 {
 	return ptr
 }
 
+func (a *arena) bytes(b []byte) uint32 {
+	if b == nil {
+		return 0
+	}
+	ptr := a.new(uint64(len(b)))
+	util.WriteBytes(a.m.mod, ptr, b)
+	return ptr
+}
+
 func (a *arena) string(s string) uint32 {
 	ptr := a.new(uint64(len(s) + 1))
 	util.WriteString(a.m.mod, ptr, s)

module_test.go

@@ -26,14 +26,14 @@ func TestConn_error_OOM(t *testing.T) {
 	t.Error("want panic")
 }
 
-func TestConn_call_nil(t *testing.T) {
+func TestConn_call_closed(t *testing.T) {
 	t.Parallel()
 
 	m, err := instantiateModule()
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer m.close()
+	m.close()
 
 	defer func() { _ = recover() }()
 	m.call(m.api.free)

tests/blob_test.go

@@ -5,6 +5,7 @@ import (
 	"crypto/rand"
 	"errors"
 	"fmt"
+	"hash/adler32"
 	"io"
 	"testing"
 
@@ -48,17 +49,17 @@ func TestBlob(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	_, err = io.Copy(blob, bytes.NewReader(data[:size/2]))
+	_, err = blob.Write(data[:size/2])
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	_, err = io.Copy(blob, bytes.NewReader(data[:]))
-	if !errors.Is(err, sqlite3.ERROR) {
-		t.Fatal("want error")
+	n, err := blob.Write(data[:])
+	if n != 0 || !errors.Is(err, sqlite3.ERROR) {
+		t.Fatalf("got (%d, %v), want (0, ERROR)", n, err)
 	}
 
-	_, err = io.Copy(blob, bytes.NewReader(data[size/2:size]))
+	_, err = blob.Write(data[size/2 : size])
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -87,6 +88,126 @@ func TestBlob(t *testing.T) {
 	}
 }
 
+func TestBlob_large(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.Exec(`CREATE TABLE IF NOT EXISTS test (col)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`INSERT INTO test VALUES (zeroblob(1000000))`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	blob, err := db.OpenBlob("main", "test", "col", db.LastInsertRowID(), true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer blob.Close()
+
+	size := blob.Size()
+	if size != 1000000 {
+		t.Errorf("got %d, want 1000000", size)
+	}
+
+	hash := adler32.New()
+	_, err = io.CopyN(blob, io.TeeReader(rand.Reader, hash), 1000000)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = blob.Seek(0, io.SeekStart)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want := hash.Sum32()
+	hash.Reset()
+	_, err = io.Copy(hash, blob)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if got := hash.Sum32(); got != want {
+		t.Fatalf("got %d, want %d", got, want)
+	}
+
+	if err := blob.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := db.Close(); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestBlob_overflow(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.Exec(`CREATE TABLE IF NOT EXISTS test (col)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`INSERT INTO test VALUES (zeroblob(1024))`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	blob, err := db.OpenBlob("main", "test", "col", db.LastInsertRowID(), true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer blob.Close()
+
+	n, err := blob.ReadFrom(rand.Reader)
+	if n != 1024 || !errors.Is(err, sqlite3.ERROR) {
+		t.Fatalf("got (%d, %v), want (0, ERROR)", n, err)
+	}
+
+	n, err = blob.ReadFrom(rand.Reader)
+	if n != 0 || !errors.Is(err, sqlite3.ERROR) {
+		t.Fatalf("got (%d, %v), want (0, ERROR)", n, err)
+	}
+
+	_, err = blob.Seek(-128, io.SeekEnd)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	n, err = blob.WriteTo(io.Discard)
+	if n != 128 || err != nil {
+		t.Fatalf("got (%d, %v), want (128, nil)", n, err)
+	}
+
+	n, err = blob.WriteTo(io.Discard)
+	if n != 0 || err != nil {
+		t.Fatalf("got (%d, %v), want (0, nil)", n, err)
+	}
+
+	if err := blob.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := db.Close(); err != nil {
+		t.Fatal(err)
+	}
+}
+
 func TestBlob_invalid(t *testing.T) {
 	t.Parallel()
 

tx.go

@@ -69,7 +69,7 @@ func (tx Tx) End(errp *error) {
 		defer panic(recovered)
 	}
 
-	if (errp == nil || *errp == nil) && recovered == nil {
+	if *errp == nil && recovered == nil {
 		// Success path.
 		if tx.c.GetAutocommit() { // There is nothing to commit.
 			return
@@ -155,7 +155,7 @@ func (s Savepoint) Release(errp *error) {
 		defer panic(recovered)
 	}
 
-	if (errp == nil || *errp == nil) && recovered == nil {
+	if *errp == nil && recovered == nil {
 		// Success path.
 		if s.c.GetAutocommit() { // There is nothing to commit.
 			return