Merge branch 'master' into xforwardedfor_fix

Bump github.com/stretchr/testify from 1.8.4 to 1.9.0

client/command/alias/load.go

@@ -57,7 +57,7 @@ var (
 
 	defaultHostProc = map[string]string{
 		"windows": windowsDefaultHostProc,
-		"linux":   windowsDefaultHostProc,
+		"linux":   linuxDefaultHostProc,
 		"darwin":  macosDefaultHostProc,
 	}
 )

client/command/extensions/load.go

@@ -99,6 +99,7 @@ type ExtCommand struct {
 	Arguments   []*extensionArgument `json:"arguments"`
 	Entrypoint  string               `json:"entrypoint"`
 	DependsOn   string               `json:"depends_on"`
+	Init        string               `json:"init"`
 
 	Manifest *ExtensionManifest
 }
@@ -371,38 +372,50 @@ func loadExtension(goos string, goarch string, checkCache bool, ext *ExtCommand,
 		}
 		extensionList = extList.Names
 	}
-	depLoaded := false
+	//extensionList contains all *implant* loaded extensions. Is a sha256 sum of the relevant file.
+
+	//get the file hash to compare against implant extensions later
+	toberunfilepath, err := ext.getFileForTarget(goos, goarch)
+	if err != nil {
+		return err
+	}
+	//we need to check the dependent if it's a bof
+	if ext.DependsOn != "" {
+		//verify extension is in loaded list
+		if extension, found := loadedExtensions[ext.DependsOn]; found {
+			toberunfilepath, err = extension.getFileForTarget(goos, goarch)
+			if err != nil {
+				return err
+			}
+		} else {
+			// handle error
+			return fmt.Errorf("attempted to load non-existing extension: %s", ext.DependsOn)
+		}
+	}
+
+	//todo, maybe cache these values somewhere
+	toberunfiledata, err := os.ReadFile(toberunfilepath)
+	if err != nil {
+		return err
+	}
+	if len(toberunfiledata) == 0 {
+		//read an empty file, bail out
+		return errors.New("read empty extension file content")
+	}
+	bd := sha256.Sum256(toberunfiledata)
+	toberunhash := hex.EncodeToString(bd[:])
+
 	for _, extName := range extensionList {
-		if !depLoaded {
-			if extN, ok := loadedExtensions[cmd.Name()]; ok && extName == extN.DependsOn {
-				depLoaded = true
-			}
-		}
-		//check if the file suffixes are the same (should only be relevant to the same extension package), and don't load the file if it's already there
-		extN := loadedExtensions[cmd.Name()]
-		if extN != nil {
-			//confirm we haven't already loaded the file
-			for _, extf := range extN.Files {
-				if strings.HasSuffix(binPath, extf.Path) {
-					//file already exists, no need to load it
-					return nil
-				}
-			}
-		}
-		if extN, ok := loadedExtensions[cmd.Name()]; ok && extN.CommandName == extName {
+		//check if extension we are trying to run (ext.CommandName or ext.DependsOn, for bofs) is already loaded
+		if extName == toberunhash {
+			//exists on the other side, exit early
 			return nil
 		}
 	}
 	// Extension not found, let's load it
-	if filepath.Ext(binPath) == ".o" {
-		// BOFs are not loaded by the DLL loader, but we make sure the loader itself is loaded
-		// Auto load the coff loader if we have it
-		if !depLoaded {
-			if errLoad := loadDep(goos, goarch, ext.DependsOn, cmd, con); errLoad != nil {
-				return errLoad
-			}
-		}
-		return nil
+	// BOFs are not loaded by the DLL loader, but we need to load the loader (more load more good)
+	if ext.DependsOn != "" {
+		return loadDep(goos, goarch, ext.DependsOn, cmd, con)
 	}
 	binData, err := os.ReadFile(binPath)
 	if err != nil {
@@ -414,17 +427,45 @@ func loadExtension(goos string, goarch string, checkCache bool, ext *ExtCommand,
 	return nil
 }
 
-func registerExtension(goos string, _ *ExtCommand, binData []byte, cmd *cobra.Command, con *console.SliverClient) error {
+func registerExtension(goos string, ext *ExtCommand, binData []byte, cmd *cobra.Command, con *console.SliverClient) error {
 	//set extension name to a hash of the data to avoid loading more than one instance
 	bd := sha256.Sum256(binData)
 	name := hex.EncodeToString(bd[:])
+	sess, beac := con.ActiveTarget.GetInteractive()
+	ctrl := make(chan bool)
+	//first time run of an extension will require some waiting depending on the size
+	if sess != nil {
+		msg := fmt.Sprintf("Sending %s to implant ...", ext.CommandName)
+		con.SpinUntil(msg, ctrl)
+	}
+	//don't block if we are in beacon mode
+	if beac != nil && sess == nil {
+		go func() {
+			registerResp, err := con.Rpc.RegisterExtension(context.Background(), &sliverpb.RegisterExtensionReq{
+				Name:    name,
+				Data:    binData,
+				OS:      goos,
+				Init:    ext.Init,
+				Request: con.ActiveTarget.Request(cmd),
+			})
+			if err != nil {
+				con.PrintErrorf("Error registering extension: %s\n", err)
+			}
+			if registerResp.Response != nil && registerResp.Response.Err != "" {
+				con.PrintErrorf("Error registering extension: %s\n", errors.New(registerResp.Response.Err))
+			}
+		}()
+		return nil
+	}
+	//session mode (hopefully)
 	registerResp, err := con.Rpc.RegisterExtension(context.Background(), &sliverpb.RegisterExtensionReq{
-		Name: name,
-		Data: binData,
-		OS:   goos,
-		//Init:    ext.Init, ?
+		Name:    name,
+		Data:    binData,
+		OS:      goos,
 		Request: con.ActiveTarget.Request(cmd),
 	})
+	ctrl <- true
+	<-ctrl
 	if err != nil {
 		return err
 	}
@@ -525,6 +566,33 @@ func runExtensionCmd(cmd *cobra.Command, con *console.SliverClient, args []strin
 	}
 	bd := sha256.Sum256(extdata)
 	name := hex.EncodeToString(bd[:])
+	if isBOF {
+		//if we are using a bof, we are actually calling the coffloader extension - so get the file from dep ref and use that shasum
+
+		if extension, found := loadedExtensions[ext.DependsOn]; found {
+			dep, err := extension.getFileForTarget(goos, goarch)
+			if err != nil {
+				con.PrintErrorf("could not get file for extension %s", ext.DependsOn)
+				return
+			}
+			depdata, err := os.ReadFile(dep)
+			if err != nil {
+				con.PrintErrorf("dep read file error: %s\n", err)
+				return
+			}
+			if len(depdata) == 0 {
+				con.PrintErrorf("read empty file: %s\n", dep)
+				return
+			}
+			bd = sha256.Sum256(depdata)
+			name = hex.EncodeToString(bd[:])
+		} else {
+			// handle error
+			con.PrintErrorf("attempted to load non-existing extension: %s", ext.DependsOn)
+			return
+		}
+
+	}
 	callExtResp, err := con.Rpc.CallExtension(context.Background(), &sliverpb.CallExtensionReq{
 		Name:    name,
 		Export:  entryPoint,
@@ -579,7 +647,7 @@ func getExtArgs(_ *cobra.Command, args []string, _ string, ext *ExtCommand) ([]b
 	missingRequiredArgs := make([]string, 0)
 
 	// If we have an extension that expects a single string, but more than one has been parsed, combine them
-	if len(ext.Arguments) == 1 && strings.Contains(ext.Arguments[0].Type, "string") {
+	if len(ext.Arguments) == 1 && strings.Contains(ext.Arguments[0].Type, "string") && len(args) > 0 {
 		// The loop below will only read the first element of args because ext.Arguments is 1
 		args[0] = strings.Join(args, " ")
 	}

client/command/generate/commands.go

@@ -184,6 +184,28 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 	}
 	profilesCmd.AddCommand(profilesNewCmd)
 
+	profilesStageCmd := &cobra.Command{
+		Use:   consts.StageStr,
+		Short: "Generate implant from a profile and encode or encrypt it",
+		Args:  cobra.ExactArgs(1),
+		Long:  help.GetHelpFor([]string{consts.ProfilesStr, consts.StageStr}),
+		Run: func(cmd *cobra.Command, args []string) {
+			ProfilesStageCmd(cmd, con, args)
+		},
+	}
+	flags.Bind("profiles", false, profilesStageCmd, func(f *pflag.FlagSet) {
+		f.StringP("save", "s", "", "directory/file to the binary to")
+		f.StringP("name", "n", "", "Implant name")
+		f.StringP("aes-encrypt-key", "k", "", "AES Encryption Key")
+		f.StringP("aes-encrypt-iv", "i", "", "AES Encryption IV")
+		f.StringP("rc4-encrypt-key", "r", "", "RC4 encryption key")
+		f.BoolP("prepend-size", "p", false, "Prepend stage size")
+		f.StringP("compress", "c", "", "Compress stage (zlib, gzip, deflate9 or deflate)")
+	})
+
+	carapace.Gen(profilesStageCmd).PositionalCompletion(ProfileNameCompleter(con))
+	profilesCmd.AddCommand(profilesStageCmd)
+
 	// Session flags and completions.
 	coreImplantFlags("session", profilesNewCmd)
 	compileImplantFlags("session", profilesNewCmd)

client/command/help/long-help.go

@@ -108,6 +108,7 @@ var (
 		// Profiles
 		consts.ProfilesStr + sep + consts.NewStr:      newProfileHelp,
 		consts.ProfilesStr + sep + consts.GenerateStr: generateProfileHelp,
+		consts.ProfilesStr + sep + consts.StageStr:    generateProfileStageHelp,
 
 		// Reactions
 		consts.ReactionStr:                         reactionHelp,
@@ -249,6 +250,9 @@ settings. Generated implants will still have per-binary certificates/obfuscation
 	generateProfileHelp = `[[.Bold]]Command:[[.Normal]] generate [name] <options>
 [[.Bold]]About:[[.Normal]] Generate an implant from a saved profile (see 'profiles new --help').`
 
+	generateProfileStageHelp = `[[.Bold]]Command:[[.Normal]] stage [name] <options>
+	[[.Bold]]About:[[.Normal]] Generate and encrypt or encode an implant from a saved profile (see 'profiles stage --help').`
+
 	msfHelp = `[[.Bold]]Command:[[.Normal]] msf [--lhost] <options>
 [[.Bold]]About:[[.Normal]] Execute a metasploit payload in the current process.`
 

client/command/update/update.go

@@ -264,11 +264,13 @@ func downloadAsset(client *http.Client, asset *version.Asset, saveTo string) err
 	if err != nil {
 		return err
 	}
+	defer writer.Close()
 
 	resp, err := client.Get(asset.BrowserDownloadURL)
 	if err != nil {
 		return err
 	}
+	defer resp.Body.Close()
 
 	bar := pb.Full.Start64(limit)
 	barReader := bar.NewProxyReader(resp.Body)

client/command/wireguard/wg-config.go

@@ -88,7 +88,7 @@ func WGConfigCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 
 	save, _ := cmd.Flags().GetString("save")
 	if save == "" {
-		con.PrintInfof("New client config:")
+		con.PrintInfof("New client config:\n")
 		con.Println(output.String())
 	} else {
 		if !strings.HasSuffix(save, ".conf") {

docs/sliver-docs/components/markdown.tsx

@@ -7,6 +7,7 @@ import { useRouter } from "next/router";
 import Markdown from "react-markdown";
 import remarkGfm from "remark-gfm";
 import AsciinemaPlayer from "./asciinema";
+import Youtube from "./youtube";
 
 export type MarkdownProps = {
   key?: string;
@@ -131,6 +132,11 @@ const MarkdownViewer = (props: MarkdownProps) => {
               );
             }
 
+            if (lang === "youtube") {
+              const embedId = (children as string) || "";
+              return <Youtube embedId={embedId.trim()} />;
+            }
+
             if (lang === "asciinema") {
               const asciiCast: MarkdownAsciiCast = JSON.parse(
                 children as string

docs/sliver-docs/components/youtube.tsx

@@ -0,0 +1,22 @@
+export type YoutubeProps = {
+  className?: string;
+
+  width?: number;
+  height?: number;
+
+  embedId: string;
+};
+
+export default function Youtube(props: YoutubeProps) {
+  return (
+    <div className={props.className}>
+      <iframe
+        width={`${props.width ? props.width : 640}`}
+        height={`${props.height ? props.height : 360}`}
+        src={`https://youtu.be/embed/${props.embedId}`}
+        allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+        allowFullScreen
+      />
+    </div>
+  );
+}

docs/sliver-docs/pages/_document.tsx

@@ -2,7 +2,7 @@ import Document, { Head, Html, Main, NextScript } from "next/document";
 import React from "react";
 
 // This generates the https: and wss: "connect-src" directives based on the above backends list so its a little easier to edit.
-const CSP = `default-src 'none'; script-src 'self' 'unsafe-eval'; img-src 'self'; style-src 'self' 'unsafe-inline'; font-src 'self'; connect-src 'self'`;
+const CSP = `default-src 'none'; script-src 'self' 'unsafe-eval'; img-src 'self'; style-src 'self' 'unsafe-inline'; font-src 'self'; frame-src https://youtu.be; connect-src 'self'`;
 
 class MyDocument extends Document {
   static async getInitialProps(ctx: any) {
@@ -17,7 +17,6 @@ class MyDocument extends Document {
     return (
       <Html lang="en">
         <Head>
-          <title>Sliver Docs</title>
           <meta httpEquiv="Content-Security-Policy" content={CSP} />
         </Head>
         <body>

docs/sliver-docs/pages/docs/md/Community Guides.md

@@ -7,10 +7,10 @@
 ### Videos
 
 - https://youtu.be/3R6WKUgN0K4?t=456
-- https://www.youtube.com/watch?v=QO_1UMaiWHk
-- https://www.youtube.com/watch?v=izMMmOaLn9g
-- https://www.youtube.com/watch?v=qIbrozlf2wM
-- https://www.youtube.com/watch?v=CKfjLnEMfvI
+- https://youtu.be/watch?v=QO_1UMaiWHk
+- https://youtu.be/watch?v=izMMmOaLn9g
+- https://youtu.be/watch?v=qIbrozlf2wM
+- https://youtu.be/watch?v=CKfjLnEMfvI
 
 ### Blogs
 

go.mod

@@ -19,13 +19,13 @@ require (
 	github.com/chromedp/cdproto v0.0.0-20240426225625-909263490071
 	github.com/chromedp/chromedp v0.9.5
 	github.com/fatih/color v1.16.0
-	github.com/glebarez/sqlite v1.10.0
+	github.com/glebarez/sqlite v1.11.0
 	github.com/gofrs/uuid v4.4.0+incompatible
 	github.com/golang/protobuf v1.5.4
 	github.com/google/uuid v1.6.0
 	github.com/gorilla/mux v1.8.1
 	github.com/grpc-ecosystem/go-grpc-middleware v1.4.0
-	github.com/jedib0t/go-pretty/v6 v6.5.8
+	github.com/jedib0t/go-pretty/v6 v6.5.9
 	github.com/kbinani/screenshot v0.0.0-20191211154542-3a185f1ce18f
 	github.com/klauspost/compress v1.17.8
 	github.com/lesnuages/go-winio v0.4.19
@@ -34,14 +34,14 @@ require (
 	github.com/miekg/dns v1.1.59
 	github.com/moloch--/asciicast v0.1.0
 	github.com/moloch--/memmod v0.0.0-20230225130813-fd77d905589e
-	github.com/ncruces/go-sqlite3 v0.7.2
+	github.com/ncruces/go-sqlite3 v0.15.0
 	github.com/reeflective/console v0.1.15
 	github.com/reeflective/readline v1.0.14
 	github.com/rsteube/carapace v0.46.3-0.20231214181515-27e49f3c3b69
 	github.com/sirupsen/logrus v1.9.3
 	github.com/spf13/cobra v1.8.0
 	github.com/spf13/pflag v1.0.5
-	github.com/stretchr/testify v1.8.4
+	github.com/stretchr/testify v1.9.0
 	github.com/tetratelabs/wazero v1.7.1
 	github.com/things-go/go-socks5 v0.0.5
 	github.com/ulikunitz/xz v0.5.12
@@ -52,7 +52,7 @@ require (
 	golang.org/x/net v0.24.0
 	golang.org/x/sys v0.19.0
 	golang.org/x/term v0.19.0
-	golang.org/x/text v0.14.0
+	golang.org/x/text v0.15.0
 	golang.zx2c4.com/wireguard v0.0.0-20231211153847-12269c276173
 	golang.zx2c4.com/wireguard/wgctrl v0.0.0-20230429144221-925a1e7659e6
 	google.golang.org/grpc v1.63.2
@@ -150,7 +150,7 @@ require (
 	github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d // indirect
 	github.com/mitchellh/go-ps v1.0.0 // indirect
 	github.com/ncruces/go-strftime v0.1.9 // indirect
-	github.com/ncruces/julianday v0.1.5 // indirect
+	github.com/ncruces/julianday v1.0.0 // indirect
 	github.com/pierrec/lz4/v4 v4.1.21 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect

go.sum

@@ -143,8 +143,8 @@ github.com/github/fakeca v0.1.0 h1:Km/MVOFvclqxPM9dZBC4+QE564nU4gz4iZ0D9pMw28I=
 github.com/github/fakeca v0.1.0/go.mod h1:+bormgoGMMuamOscx7N91aOuUST7wdaJ2rNjeohylyo=
 github.com/glebarez/go-sqlite v1.21.2 h1:3a6LFC4sKahUunAmynQKLZceZCOzUthkRkEAl9gAXWo=
 github.com/glebarez/go-sqlite v1.21.2/go.mod h1:sfxdZyhQjTM2Wry3gVYWaW072Ri1WMdWJi0k6+3382k=
-github.com/glebarez/sqlite v1.10.0 h1:u4gt8y7OND/cCei/NMHmfbLxF6xP2wgKcT/BJf2pYkc=
-github.com/glebarez/sqlite v1.10.0/go.mod h1:IJ+lfSOmiekhQsFTJRx/lHtGYmCdtAiTaf5wI9u5uHA=
+github.com/glebarez/sqlite v1.11.0 h1:wSG0irqzP6VurnMEpFGer5Li19RpIRi2qvQz++w0GMw=
+github.com/glebarez/sqlite v1.11.0/go.mod h1:h8/o8j5wiAsqSPoWELDUdJXhjAhsVliSn7bWZjOhrgQ=
 github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
 github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
 github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
@@ -221,8 +221,8 @@ github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk
 github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
 github.com/jcmturner/gofork v1.0.0 h1:J7uCkflzTEhUZ64xqKnkDxq3kzc96ajM1Gli5ktUem8=
 github.com/jcmturner/gofork v1.0.0/go.mod h1:MK8+TM0La+2rjBD4jE12Kj1pCCxK7d2LK/UM3ncEo0o=
-github.com/jedib0t/go-pretty/v6 v6.5.8 h1:8BCzJdSvUbaDuRba4YVh+SKMGcAAKdkcF3SVFbrHAtQ=
-github.com/jedib0t/go-pretty/v6 v6.5.8/go.mod h1:zbn98qrYlh95FIhwwsbIip0LYpwSG8SUOScs+v9/t0E=
+github.com/jedib0t/go-pretty/v6 v6.5.9 h1:ACteMBRrrmm1gMsXe9PSTOClQ63IXDUt03H5U+UV8OU=
+github.com/jedib0t/go-pretty/v6 v6.5.9/go.mod h1:zbn98qrYlh95FIhwwsbIip0LYpwSG8SUOScs+v9/t0E=
 github.com/jellydator/ttlcache/v3 v3.1.0 h1:0gPFG0IHHP6xyUyXq+JaD8fwkDCqgqwohXNJBcYE71g=
 github.com/jellydator/ttlcache/v3 v3.1.0/go.mod h1:hi7MGFdMAwZna5n2tuvh63DvFLzVKySzCVW6+0gA2n4=
 github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
@@ -303,12 +303,12 @@ github.com/moloch--/asciicast v0.1.0 h1:eBOJwuFKSk447s/kPs9MWsc4kAl5HmuKIDLDYD6/
 github.com/moloch--/asciicast v0.1.0/go.mod h1:OckO16UDLgxVLclrCnbocL1ix15Br/8Xv/caBoYq98o=
 github.com/moloch--/memmod v0.0.0-20230225130813-fd77d905589e h1:IkFCPlAa0iTiLxck+NqAwBx8JDlnHYm4orOQBbs4BDQ=
 github.com/moloch--/memmod v0.0.0-20230225130813-fd77d905589e/go.mod h1:eYeI6cQ5YHhHt9i0BBW0zc1DaQnb4ZMXsSPuEV/V5Og=
-github.com/ncruces/go-sqlite3 v0.7.2 h1:K7jU4rnUxFdUsbEL+B0Xc+VexLTEwGSO6Qh91Qh4hYc=
-github.com/ncruces/go-sqlite3 v0.7.2/go.mod h1:t3dP4AP9rJddU+ffFv0h6fWyeOCEhjxrYc1nsYG7aQI=
+github.com/ncruces/go-sqlite3 v0.15.0 h1:C+SIrcYsAIR5GUYWmCnif6x81n6BS9y75vYcQynuGNU=
+github.com/ncruces/go-sqlite3 v0.15.0/go.mod h1:kHHYmFmK4G2VFFoIovEg9BEQ8BP+D81y4ESHXnzJV/w=
 github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
 github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
-github.com/ncruces/julianday v0.1.5 h1:hDJ9ejiMp3DHsoZ5KW4c1lwfMjbARS7u/gbYcd0FBZk=
-github.com/ncruces/julianday v0.1.5/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g=
+github.com/ncruces/julianday v1.0.0 h1:fH0OKwa7NWvniGQtxdJRxAgkBMolni2BjDHaWTxqt7M=
+github.com/ncruces/julianday v1.0.0/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g=
 github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 h1:zYyBkD/k9seD2A7fsi6Oo2LfFZAehjjQMERAvZLEDnQ=
 github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646/go.mod h1:jpp1/29i3P1S/RLdc7JQKbRpFeM1dOBd8T9ki5s+AY8=
 github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
@@ -358,8 +358,8 @@ github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UV
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/tailscale/certstore v0.1.1-0.20231202035212-d3fa0460f47e h1:PtWT87weP5LWHEY//SWsYkSO3RWRZo4OSWagh3YD2vQ=
 github.com/tailscale/certstore v0.1.1-0.20231202035212-d3fa0460f47e/go.mod h1:XrBNfAFN+pwoWuksbFS9Ccxnopa15zJGgXRFN90l3K4=
 github.com/tailscale/go-winio v0.0.0-20231025203758-c4f33415bf55 h1:Gzfnfk2TWrk8Jj4P4c1a3CtQyMaTVCznlkLZI++hok4=
@@ -507,8 +507,8 @@ golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
-golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
+golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=
 golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

implant/sliver/handlers/handlers.go

@@ -155,7 +155,7 @@ func dirListHandler(data []byte, resp RPCResponse) {
 
 	path, filter := determineDirPathFilter(targetPath)
 
-	dir, files, err := getDirList(path)
+	dir, rootDirEntry, files, err := getDirList(path)
 
 	// Convert directory listing to protobuf
 	timezone, offset := time.Now().Zone()
@@ -166,6 +166,19 @@ func dirListHandler(data []byte, resp RPCResponse) {
 		dirList.Exists = false
 	}
 	dirList.Files = []*sliverpb.FileInfo{}
+	rootDirInfo, err := rootDirEntry.Info()
+	if err == nil && filter == "" {
+		// We should not get an error because we created the DirEntry object from the FileInfo object
+		dirList.Files = append(dirList.Files, &sliverpb.FileInfo{
+			Name:    ".", // Cannot use the name from the FileInfo / DirEntry because that is the name of the directory
+			Size:    rootDirInfo.Size(),
+			ModTime: rootDirInfo.ModTime().Unix(),
+			Mode:    rootDirInfo.Mode().String(),
+			Uid:     getUid(rootDirInfo),
+			Gid:     getGid(rootDirInfo),
+			IsDir:   rootDirInfo.IsDir(),
+		})
+	}
 
 	var match bool = false
 	var linkPath string = ""
@@ -226,19 +239,30 @@ func dirListHandler(data []byte, resp RPCResponse) {
 	resp(data, err)
 }
 
-func getDirList(target string) (string, []fs.DirEntry, error) {
+func getDirList(target string) (string, fs.DirEntry, []fs.DirEntry, error) {
 	dir, err := filepath.Abs(target)
 	if err != nil {
 		// {{if .Config.Debug}}
 		log.Printf("dir list failed to construct path %s", err)
 		// {{end}}
-		return "", nil, err
+		return "", nil, nil, err
 	}
-	if _, err := os.Stat(dir); !os.IsNotExist(err) {
+	if rootInfo, err := os.Stat(dir); !os.IsNotExist(err) {
+		/*
+			We could place the entry for the directory itself
+			at the beginning of the returned slice of DirEntry
+			objects, but then it is not clear if that is the
+			root directory or a directory / file in the root
+			directory with the same name as the root directory.
+
+			Using WalkDir is not great here because you cannot
+			tell it to not be recursive, so we will be wasting
+			cycles telling it to skip directories and files
+		*/
 		files, err := os.ReadDir(dir)
-		return dir, files, err
+		return dir, fs.FileInfoToDirEntry(rootInfo), files, err
 	}
-	return dir, []fs.DirEntry{}, errors.New("directory does not exist")
+	return dir, nil, []fs.DirEntry{}, errors.New("directory does not exist")
 }
 
 func rmHandler(data []byte, resp RPCResponse) {

implant/sliver/handlers/handlers_linux.go

@@ -31,8 +31,8 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/bishopfox/sliver/implant/sliver/procdump"
 	"github.com/bishopfox/sliver/implant/sliver/mount"
+	"github.com/bishopfox/sliver/implant/sliver/procdump"
 	"github.com/bishopfox/sliver/implant/sliver/taskrunner"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
@@ -190,7 +190,7 @@ func memfilesListHandler(_ []byte, resp RPCResponse) {
 
 	pid := os.Getpid()
 	path := fmt.Sprintf("/proc/%d/fd/", pid)
-	dir, files, err := getDirList(path)
+	dir, rootDirEntry, files, err := getDirList(path)
 
 	// Convert directory listing to protobuf
 	timezone, offset := time.Now().Zone()
@@ -201,6 +201,19 @@ func memfilesListHandler(_ []byte, resp RPCResponse) {
 		dirList.Exists = false
 	}
 	dirList.Files = []*sliverpb.FileInfo{}
+	rootDirInfo, err := rootDirEntry.Info()
+	if err == nil {
+		// We should not get an error because we created the DirEntry object from the FileInfo object
+		dirList.Files = append(dirList.Files, &sliverpb.FileInfo{
+			Name:    ".", // Cannot use the name from the FileInfo / DirEntry because that is the name of the directory
+			Size:    rootDirInfo.Size(),
+			ModTime: rootDirInfo.ModTime().Unix(),
+			Mode:    rootDirInfo.Mode().String(),
+			Uid:     getUid(rootDirInfo),
+			Gid:     getGid(rootDirInfo),
+			IsDir:   rootDirInfo.IsDir(),
+		})
+	}
 
 	for _, dirEntry := range files {
 		//log.Printf("File: %s\n", dirEntry.Name())

server/c2/http.go

@@ -810,7 +810,16 @@ func newHTTPSessionID() string {
 func getRemoteAddr(req *http.Request) string {
 	ipAddress := req.Header.Get("X-Real-Ip")
 	if ipAddress == "" {
-		ipAddress = req.Header.Get("X-Forwarded-For")
+		xForwardedFor := req.Header.Get("X-Forwarded-For")
+		if xForwardedFor != "" {
+			ips := strings.Split(xForwardedFor, ",")
+			if len(ips) > 0 {
+				// Extracts original client ip address
+				ipAddress = strings.TrimSpace(ips[0])
+			} else {
+				ipAddress = xForwardedFor
+			}
+		}
 	}
 	if ipAddress == "" {
 		return req.RemoteAddr

server/db/helpers.go

@@ -436,20 +436,74 @@ func SaveHTTPC2Config(httpC2Config *clientpb.HTTPC2Config) error {
 func HTTPC2ConfigUpdate(newConf *clientpb.HTTPC2Config, oldConf *clientpb.HTTPC2Config) error {
 	clientID, _ := uuid.FromString(oldConf.ImplantConfig.ID)
 	c2Config := models.HTTPC2ConfigFromProtobuf(newConf)
-	err := Session().Where(&models.ImplantConfig{
+
+	err := Session().Where(&models.HttpC2PathSegment{
+		HttpC2ImplantConfigID: clientID,
+	}).Delete(&models.HttpC2PathSegment{})
+	if err.Error != nil {
+		return err.Error
+	}
+
+	err = Session().Where(&models.ImplantConfig{
 		ID: clientID,
 	}).Updates(c2Config.ImplantConfig)
-	if err != nil {
+	if err.Error != nil {
+		return err.Error
+	}
+
+	for _, segment := range c2Config.ImplantConfig.PathSegments {
+		segment.HttpC2ImplantConfigID = clientID
+		err = Session().Clauses(clause.OnConflict{
+			UpdateAll: true,
+		}).Create(&segment)
+		if err.Error != nil {
+			return err.Error
+		}
+	}
+
+	serverID, _ := uuid.FromString(oldConf.ServerConfig.ID)
+
+	err = Session().Where(&models.HttpC2Cookie{
+		HttpC2ServerConfigID: serverID,
+	}).Delete(&models.HttpC2Cookie{})
+	if err.Error != nil {
+		return err.Error
+	}
+
+	err = Session().Where(&models.HttpC2Header{
+		HttpC2ServerConfigID: serverID,
+	}).Delete(&models.HttpC2Header{})
+	if err.Error != nil {
 		return err.Error
 	}
 
-	serverID, _ := uuid.FromString(oldConf.ImplantConfig.ID)
 	err = Session().Where(&models.HttpC2ServerConfig{
 		ID: serverID,
 	}).Updates(c2Config.ServerConfig)
-	if err != nil {
+	if err.Error != nil {
 		return err.Error
 	}
+
+	for _, cookie := range c2Config.ServerConfig.Cookies {
+		cookie.HttpC2ServerConfigID = serverID
+		err = Session().Clauses(clause.OnConflict{
+			UpdateAll: true,
+		}).Create(&cookie)
+		if err.Error != nil {
+			return err.Error
+		}
+	}
+
+	for _, header := range c2Config.ServerConfig.Headers {
+		header.HttpC2ServerConfigID = serverID
+		err = Session().Clauses(clause.OnConflict{
+			UpdateAll: true,
+		}).Create(&header)
+		if err.Error != nil {
+			return err.Error
+		}
+	}
+
 	return nil
 }
 

vendor/github.com/glebarez/sqlite/ddlmod.go

@@ -13,7 +13,8 @@ import (
 
 var (
 	sqliteSeparator    = "`|\"|'|\t"
-	indexRegexp        = regexp.MustCompile(fmt.Sprintf(`(?is)CREATE(?: UNIQUE)? INDEX [%v]?[\w\d-]+[%v]? ON (.*)$`, sqliteSeparator, sqliteSeparator))
+	uniqueRegexp       = regexp.MustCompile(fmt.Sprintf(`^CONSTRAINT [%v]?[\w-]+[%v]? UNIQUE (.*)$`, sqliteSeparator, sqliteSeparator))
+	indexRegexp        = regexp.MustCompile(fmt.Sprintf(`(?is)CREATE(?: UNIQUE)? INDEX [%v]?[\w\d-]+[%v]?(?s:.*?)ON (.*)$`, sqliteSeparator, sqliteSeparator))
 	tableRegexp        = regexp.MustCompile(fmt.Sprintf(`(?is)(CREATE TABLE [%v]?[\w\d-]+[%v]?)(?:\s*\((.*)\))?`, sqliteSeparator, sqliteSeparator))
 	separatorRegexp    = regexp.MustCompile(fmt.Sprintf("[%v]", sqliteSeparator))
 	columnsRegexp      = regexp.MustCompile(fmt.Sprintf(`[(,][%v]?(\w+)[%v]?`, sqliteSeparator, sqliteSeparator))
@@ -103,11 +104,24 @@ func parseDDL(strs ...string) (*ddl, error) {
 
 			for _, f := range result.fields {
 				fUpper := strings.ToUpper(f)
-				if strings.HasPrefix(fUpper, "CHECK") ||
-					strings.HasPrefix(fUpper, "CONSTRAINT") {
+				if strings.HasPrefix(fUpper, "CHECK") {
+					continue
+				}
+				if strings.HasPrefix(fUpper, "CONSTRAINT") {
+					matches := uniqueRegexp.FindStringSubmatch(f)
+					if len(matches) > 0 {
+						if columns := getAllColumns(matches[1]); len(columns) == 1 {
+							for idx, column := range result.columns {
+								if column.NameValue.String == columns[0] {
+									column.UniqueValue = sql.NullBool{Bool: true, Valid: true}
+									result.columns[idx] = column
+									break
+								}
+							}
+						}
+					}
 					continue
 				}
-
 				if strings.HasPrefix(fUpper, "PRIMARY KEY") {
 					for _, name := range getAllColumns(f) {
 						for idx, column := range result.columns {
@@ -159,14 +173,7 @@ func parseDDL(strs ...string) (*ddl, error) {
 				}
 			}
 		} else if matches := indexRegexp.FindStringSubmatch(str); len(matches) > 0 {
-			for _, column := range getAllColumns(matches[1]) {
-				for idx, c := range result.columns {
-					if c.NameValue.String == column {
-						c.UniqueValue = sql.NullBool{Bool: strings.ToUpper(strings.Fields(str)[1]) == "UNIQUE", Valid: true}
-						result.columns[idx] = c
-					}
-				}
-			}
+			// don't report Unique by UniqueIndex
 		} else {
 			return nil, errors.New("invalid DDL")
 		}
@@ -268,20 +275,6 @@ func (d *ddl) getColumns() []string {
 	return res
 }
 
-func (d *ddl) alterColumn(name, sql string) bool {
-	reg := regexp.MustCompile("^(`|'|\"| )" + regexp.QuoteMeta(name) + "(`|'|\"| ) .*?$")
-
-	for i := 0; i < len(d.fields); i++ {
-		if reg.MatchString(d.fields[i]) {
-			d.fields[i] = sql
-			return false
-		}
-	}
-
-	d.fields = append(d.fields, sql)
-	return true
-}
-
 func (d *ddl) removeColumn(name string) bool {
 	reg := regexp.MustCompile("^(`|'|\"| )" + regexp.QuoteMeta(name) + "(`|'|\"| ) .*?$")
 

vendor/github.com/glebarez/sqlite/migrator.go

@@ -79,14 +79,28 @@ func (m Migrator) AlterColumn(value interface{}, name string) error {
 	return m.RunWithoutForeignKey(func() error {
 		return m.recreateTable(value, nil, func(ddl *ddl, stmt *gorm.Statement) (*ddl, []interface{}, error) {
 			if field := stmt.Schema.LookUpField(name); field != nil {
-				if ddl.alterColumn(field.DBName, fmt.Sprintf("`%s` ?", field.DBName)) {
-					return nil, nil, fmt.Errorf("field `%s` not found in origin ddl, ddl= '%s'", name, ddl.compile())
+				var sqlArgs []interface{}
+				for i, f := range ddl.fields {
+					if matches := columnRegexp.FindStringSubmatch(f); len(matches) > 1 && matches[1] == field.DBName {
+						ddl.fields[i] = fmt.Sprintf("`%v` ?", field.DBName)
+						sqlArgs = []interface{}{m.FullDataTypeOf(field)}
+						// table created by old version might look like `CREATE TABLE ? (? varchar(10) UNIQUE)`.
+						// FullDataTypeOf doesn't contain UNIQUE, so we need to add unique constraint.
+						if strings.Contains(strings.ToUpper(matches[3]), " UNIQUE") {
+							uniName := m.DB.NamingStrategy.UniqueName(stmt.Table, field.DBName)
+							uni, _ := m.GuessConstraintInterfaceAndTable(stmt, uniName)
+							if uni != nil {
+								uniSQL, uniArgs := uni.Build()
+								ddl.addConstraint(uniName, uniSQL)
+								sqlArgs = append(sqlArgs, uniArgs...)
+							}
+						}
+						break
+					}
 				}
-
-				return ddl, []interface{}{m.FullDataTypeOf(field)}, nil
+				return ddl, sqlArgs, nil
 			}
-
-			return nil, nil, fmt.Errorf("failed to alter field with name `%s`", name)
+			return nil, nil, fmt.Errorf("failed to alter field with name %v", name)
 		})
 	})
 }
@@ -153,7 +167,7 @@ func (m Migrator) DropColumn(value interface{}, name string) error {
 
 func (m Migrator) CreateConstraint(value interface{}, name string) error {
 	return m.RunWithValue(value, func(stmt *gorm.Statement) error {
-		constraint, chk, table := m.GuessConstraintAndTable(stmt, name)
+		constraint, table := m.GuessConstraintInterfaceAndTable(stmt, name)
 
 		return m.recreateTable(value, &table,
 			func(ddl *ddl, stmt *gorm.Statement) (*ddl, []interface{}, error) {
@@ -164,12 +178,8 @@ func (m Migrator) CreateConstraint(value interface{}, name string) error {
 				)
 
 				if constraint != nil {
-					constraintName = constraint.Name
-					constraintSql, constraintValues = buildConstraint(constraint)
-				} else if chk != nil {
-					constraintName = chk.Name
-					constraintSql = "CONSTRAINT ? CHECK (?)"
-					constraintValues = []interface{}{clause.Column{Name: chk.Name}, clause.Expr{SQL: chk.Constraint}}
+					constraintName = constraint.GetName()
+					constraintSql, constraintValues = constraint.Build()
 				} else {
 					return nil, nil, nil
 				}
@@ -182,11 +192,9 @@ func (m Migrator) CreateConstraint(value interface{}, name string) error {
 
 func (m Migrator) DropConstraint(value interface{}, name string) error {
 	return m.RunWithValue(value, func(stmt *gorm.Statement) error {
-		constraint, chk, table := m.GuessConstraintAndTable(stmt, name)
+		constraint, table := m.GuessConstraintInterfaceAndTable(stmt, name)
 		if constraint != nil {
-			name = constraint.Name
-		} else if chk != nil {
-			name = chk.Name
+			name = constraint.GetName()
 		}
 
 		return m.recreateTable(value, &table,
@@ -200,11 +208,9 @@ func (m Migrator) DropConstraint(value interface{}, name string) error {
 func (m Migrator) HasConstraint(value interface{}, name string) bool {
 	var count int64
 	m.RunWithValue(value, func(stmt *gorm.Statement) error {
-		constraint, chk, table := m.GuessConstraintAndTable(stmt, name)
+		constraint, table := m.GuessConstraintInterfaceAndTable(stmt, name)
 		if constraint != nil {
-			name = constraint.Name
-		} else if chk != nil {
-			name = chk.Name
+			name = constraint.GetName()
 		}
 
 		m.DB.Raw(
@@ -317,26 +323,44 @@ func (m Migrator) DropIndex(value interface{}, name string) error {
 	})
 }
 
-func buildConstraint(constraint *schema.Constraint) (sql string, results []interface{}) {
-	sql = "CONSTRAINT ? FOREIGN KEY ? REFERENCES ??"
-	if constraint.OnDelete != "" {
-		sql += " ON DELETE " + constraint.OnDelete
-	}
+type Index struct {
+	Seq     int
+	Name    string
+	Unique  bool
+	Origin  string
+	Partial bool
+}
 
-	if constraint.OnUpdate != "" {
-		sql += " ON UPDATE " + constraint.OnUpdate
-	}
-
-	var foreignKeys, references []interface{}
-	for _, field := range constraint.ForeignKeys {
-		foreignKeys = append(foreignKeys, clause.Column{Name: field.DBName})
-	}
-
-	for _, field := range constraint.References {
-		references = append(references, clause.Column{Name: field.DBName})
-	}
-	results = append(results, clause.Table{Name: constraint.Name}, foreignKeys, clause.Table{Name: constraint.ReferenceSchema.Table}, references)
-	return
+// GetIndexes return Indexes []gorm.Index and execErr error,
+// See the [doc]
+//
+// [doc]: https://www.sqlite.org/pragma.html#pragma_index_list
+func (m Migrator) GetIndexes(value interface{}) ([]gorm.Index, error) {
+	indexes := make([]gorm.Index, 0)
+	err := m.RunWithValue(value, func(stmt *gorm.Statement) error {
+		rst := make([]*Index, 0)
+		if err := m.DB.Debug().Raw("SELECT * FROM PRAGMA_index_list(?)", stmt.Table).Scan(&rst).Error; err != nil { // alias `PRAGMA index_list(?)`
+			return err
+		}
+		for _, index := range rst {
+			if index.Origin == "u" { // skip the index was created by a UNIQUE constraint
+				continue
+			}
+			var columns []string
+			if err := m.DB.Raw("SELECT name FROM PRAGMA_index_info(?)", index.Name).Scan(&columns).Error; err != nil { // alias `PRAGMA index_info(?)`
+				return err
+			}
+			indexes = append(indexes, &migrator.Index{
+				TableName:       stmt.Table,
+				NameValue:       index.Name,
+				ColumnList:      columns,
+				PrimaryKeyValue: sql.NullBool{Bool: index.Origin == "pk", Valid: true}, // The exceptions are INTEGER PRIMARY KEY
+				UniqueValue:     sql.NullBool{Bool: index.Unique, Valid: true},
+			})
+		}
+		return nil
+	})
+	return indexes, err
 }
 
 func (m Migrator) getRawDDL(table string) (string, error) {

vendor/github.com/jedib0t/go-pretty/v6/table/README.md

@@ -7,9 +7,9 @@ Pretty-print tables into ASCII/Unicode strings.
   - Add Header(s) and Footer(s) (`AppendHeader`/`AppendFooter`)
   - Add a Separator manually after any Row (`AppendSeparator`)
   - Auto Index Rows (1, 2, 3 ...) and Columns (A, B, C, ...) (`SetAutoIndex`)
-  - Auto Merge (_not supported in CSV/HTML/Markdown/TSV modes_)
+  - Auto Merge (_not supported in CSV/Markdown/TSV modes_)
     - Cells in a Row (`RowConfig.AutoMerge`)
-    - Columns (`ColumnConfig.AutoMerge`)
+    - Columns (`ColumnConfig.AutoMerge`) (_not supported in HTML mode_)
   - Limit the length of
     - Rows (`SetAllowedRowLength`)
     - Columns (`ColumnConfig.Width*`)

vendor/github.com/jedib0t/go-pretty/v6/table/render_html.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"html"
 	"strings"
+
+	"github.com/jedib0t/go-pretty/v6/text"
 )
 
 const (
@@ -113,9 +115,9 @@ func (t *Table) htmlRenderColumn(out *strings.Builder, colStr string) {
 	out.WriteString(colStr)
 }
 
-func (t *Table) htmlRenderColumnAttributes(out *strings.Builder, colIdx int, hint renderHint) {
+func (t *Table) htmlRenderColumnAttributes(out *strings.Builder, colIdx int, hint renderHint, alignOverride text.Align) {
 	// determine the HTML "align"/"valign" property values
-	align := t.getAlign(colIdx, hint).HTMLProperty()
+	align := alignOverride.HTMLProperty()
 	vAlign := t.getVAlign(colIdx, hint).HTMLProperty()
 	// determine the HTML "class" property values for the colors
 	class := t.getColumnColors(colIdx, hint).HTMLProperty()
@@ -158,11 +160,31 @@ func (t *Table) htmlRenderRow(out *strings.Builder, row rowStr, hint renderHint)
 			t.htmlRenderColumnAutoIndex(out, hint)
 		}
 
+		align := t.getAlign(colIdx, hint)
+		rowConfig := t.getRowConfig(hint)
+		extraColumnsRendered := 0
+		if rowConfig.AutoMerge && !hint.isSeparatorRow {
+			// get the real row to consider all lines in each column instead of just
+			// looking at the current "line"
+			rowUnwrapped := t.getRow(hint.rowNumber-1, hint)
+			for idx := colIdx + 1; idx < len(rowUnwrapped); idx++ {
+				if rowUnwrapped[colIdx] != rowUnwrapped[idx] {
+					break
+				}
+				align = rowConfig.getAutoMergeAlign()
+				extraColumnsRendered++
+			}
+		}
+
 		colStr, colTagName := t.htmlGetColStrAndTag(row, colIdx, hint)
 		// write the row
 		out.WriteString("    <")
 		out.WriteString(colTagName)
-		t.htmlRenderColumnAttributes(out, colIdx, hint)
+		t.htmlRenderColumnAttributes(out, colIdx, hint, align)
+		if extraColumnsRendered > 0 {
+			out.WriteString(" colspan=")
+			out.WriteString(fmt.Sprint(extraColumnsRendered + 1))
+		}
 		out.WriteString(">")
 		if len(colStr) == 0 {
 			out.WriteString(t.style.HTML.EmptyColumn)
@@ -172,6 +194,7 @@ func (t *Table) htmlRenderRow(out *strings.Builder, row rowStr, hint renderHint)
 		out.WriteString("</")
 		out.WriteString(colTagName)
 		out.WriteString(">\n")
+		colIdx += extraColumnsRendered
 	}
 	out.WriteString("  </tr>\n")
 }

vendor/github.com/ncruces/go-sqlite3/README.md

@@ -4,84 +4,108 @@
 [![Go Report](https://goreportcard.com/badge/github.com/ncruces/go-sqlite3)](https://goreportcard.com/report/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` wraps a [WASM](https://webassembly.org/) build of [SQLite](https://sqlite.org/),
-and uses [wazero](https://wazero.io/) to provide `cgo`-free SQLite bindings.
+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).
 
-- Package [`github.com/ncruces/go-sqlite3`](https://pkg.go.dev/github.com/ncruces/go-sqlite3)
-wraps the [C SQLite API](https://www.sqlite.org/cintro.html)
-([example usage](https://pkg.go.dev/github.com/ncruces/go-sqlite3#example-package)).
-- 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 usage](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver#example-package)).
-- Package [`github.com/ncruces/go-sqlite3/embed`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/embed)
-embeds a build of SQLite into your application.
-- Package [`github.com/ncruces/go-sqlite3/vfs`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs)
-wraps the [C SQLite VFS API](https://www.sqlite.org/vfs.html) and provides a pure Go implementation.
-- Package [`github.com/ncruces/go-sqlite3/gormlite`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/gormlite)
-provides a [GORM](https://gorm.io) driver.
+It wraps a [Wasm](https://webassembly.org/) [build](embed/) of SQLite,
+and uses [wazero](https://wazero.io/) as the runtime.\
+Go, wazero and [`x/sys`](https://pkg.go.dev/golang.org/x/sys) are the _only_ runtime dependencies [^1].
+
+### 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 usage](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 usage](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver#example-package)).
+- [`github.com/ncruces/go-sqlite3/embed`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/embed)
+  embeds a build of SQLite into your application.
+- [`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.
+
+### Extensions
+
+- [`github.com/ncruces/go-sqlite3/ext/array`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/array)
+  provides the [`array`](https://sqlite.org/carray.html) table-valued function.
+- [`github.com/ncruces/go-sqlite3/ext/blobio`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/blobio)
+  simplifies [incremental BLOB I/O](https://sqlite.org/c3ref/blob_open.html).
+- [`github.com/ncruces/go-sqlite3/ext/csv`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/csv)
+  reads [comma-separated values](https://sqlite.org/csv.html).
+- [`github.com/ncruces/go-sqlite3/ext/fileio`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/fileio)
+  reads, writes and lists files.
+- [`github.com/ncruces/go-sqlite3/ext/hash`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/hash)
+  provides cryptographic hash functions.
+- [`github.com/ncruces/go-sqlite3/ext/lines`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/lines)
+  reads data [line-by-line](https://github.com/asg017/sqlite-lines).
+- [`github.com/ncruces/go-sqlite3/ext/pivot`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/pivot)
+  creates [pivot tables](https://github.com/jakethaw/pivot_vtab).
+- [`github.com/ncruces/go-sqlite3/ext/statement`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/statement)
+  creates [parameterized views](https://github.com/0x09/sqlite-statement-vtab).
+- [`github.com/ncruces/go-sqlite3/ext/stats`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/stats)
+  provides [statistics](https://www.oreilly.com/library/view/sql-in-a/9780596155322/ch04s02.html) functions.
+- [`github.com/ncruces/go-sqlite3/ext/unicode`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/unicode)
+  provides [Unicode aware](https://sqlite.org/src/dir/ext/icu) functions.
+- [`github.com/ncruces/go-sqlite3/ext/zorder`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/zorder)
+  maps multidimensional data to one dimension.
+- [`github.com/ncruces/go-sqlite3/vfs/memdb`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs/memdb)
+  implements an in-memory VFS.
+- [`github.com/ncruces/go-sqlite3/vfs/readervfs`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs/readervfs)
+  implements a VFS for immutable databases.
+- [`github.com/ncruces/go-sqlite3/vfs/adiantum`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs/adiantum)
+  wraps a VFS to offer encryption at rest.
+
+### Advanced features
+
+- [incremental BLOB I/O](https://sqlite.org/c3ref/blob_open.html)
+- [nested transactions](https://sqlite.org/lang_savepoint.html)
+- [custom functions](https://sqlite.org/c3ref/create_function.html)
+- [virtual tables](https://sqlite.org/vtab.html)
+- [custom VFSes](https://sqlite.org/vfs.html)
+- [online backup](https://sqlite.org/backup.html)
+- [JSON support](https://sqlite.org/json1.html)
+- [math functions](https://sqlite.org/lang_mathfunc.html)
+- [full-text search](https://sqlite.org/fts5.html)
+- [geospatial search](https://sqlite.org/geopoly.html)
+- [encryption at rest](vfs/adiantum/README.md)
+- [and more…](embed/README.md)
 
 ### Caveats
 
-This module replaces the SQLite [OS Interface](https://www.sqlite.org/vfs.html)
-(aka VFS) with a [pure Go](vfs/) implementation.
-This has benefits, but also comes with some drawbacks.
+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.
 
-#### Write-Ahead Logging
+Read more about the Go VFS design [here](vfs/README.md).
 
-Because WASM does not support shared memory,
-[WAL](https://www.sqlite.org/wal.html) support is [limited](https://www.sqlite.org/wal.html#noshm).
+### Testing
 
-To work around this limitation, SQLite is compiled with
-[`SQLITE_DEFAULT_LOCKING_MODE=1`](https://www.sqlite.org/compile.html#default_locking_mode),
-making `EXCLUSIVE` the default locking mode.
-For non-WAL databases, `NORMAL` locking mode can be activated with
-[`PRAGMA locking_mode=NORMAL`](https://www.sqlite.org/pragma.html#pragma_locking_mode).
+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) and
+[wazero's](https://tetrate.io/blog/introducing-wazero-from-tetrate/#:~:text=Rock%2Dsolid%20test%20approach) thorough testing.
 
-Because connection pooling is incompatible with `EXCLUSIVE` locking mode,
-the `database/sql` driver defaults to `NORMAL` locking mode.
-To open WAL databases, or use `EXCLUSIVE` locking mode,
-disable connection pooling by calling
-[`db.SetMaxOpenConns(1)`](https://pkg.go.dev/database/sql#DB.SetMaxOpenConns).
+Every commit is [tested](.github/workflows/test.yml) on
+Linux (amd64/arm64/386/riscv64), macOS (amd64/arm64), Windows, FreeBSD and illumos.
+The Go VFS is tested by running SQLite's
+[mptest](https://github.com/sqlite/sqlite/blob/master/mptest/mptest.c).
 
-#### POSIX Advisory Locks
+### Performance
 
-POSIX advisory locks, which SQLite uses, are
-[broken by design](https://www.sqlite.org/src/artifact/90c4fa?ln=1073-1161).
+Perfomance of the [`database/sql`](https://pkg.go.dev/database/sql) driver is
+[competitive](https://github.com/cvilsmeier/go-sqlite-bench) with alternatives.
 
-On Linux, macOS and illumos, this module uses
-[OFD locks](https://www.gnu.org/software/libc/manual/html_node/Open-File-Description-Locks.html)
-to synchronize access to database files.
-OFD locks are fully compatible with process-associated POSIX advisory locks.
-
-On BSD Unixes, this module uses
-[BSD locks](https://man.freebsd.org/cgi/man.cgi?query=flock&sektion=2).
-BSD locks may _not_ be compatible with process-associated POSIX advisory locks.
-
-#### Testing
-
-The pure Go VFS is tested by running an unmodified build of SQLite's
-[mptest](https://github.com/sqlite/sqlite/blob/master/mptest/mptest.c)
-on Linux, macOS and Windows.
-Performance is tested by running
+The Wasm and VFS layers are also tested by running SQLite's
 [speedtest1](https://github.com/sqlite/sqlite/blob/master/test/speedtest1.c).
 
-### Roadmap
-
-- [ ] advanced SQLite features
-  - [x] nested transactions
-  - [x] incremental BLOB I/O
-  - [x] online backup
-  - [ ] session extension
-- [ ] custom VFSes
-  - [x] custom VFS API
-  - [x] in-memory VFS
-  - [x] read-only VFS, wrapping an [`io.ReaderAt`](https://pkg.go.dev/io#ReaderAt)
-  - [ ] cloud-based VFS, based on [Cloud Backed SQLite](https://sqlite.org/cloudsqlite/doc/trunk/www/index.wiki)
-- [ ] custom SQL functions
-
 ### Alternatives
 
 - [`modernc.org/sqlite`](https://pkg.go.dev/modernc.org/sqlite)
 - [`crawshaw.io/sqlite`](https://pkg.go.dev/crawshaw.io/sqlite)
 - [`github.com/mattn/go-sqlite3`](https://pkg.go.dev/github.com/mattn/go-sqlite3)
-- [`github.com/zombiezen/go-sqlite`](https://pkg.go.dev/github.com/zombiezen/go-sqlite)
+- [`github.com/zombiezen/go-sqlite`](https://pkg.go.dev/github.com/zombiezen/go-sqlite)
+
+[^1]: anything else you find in `go.mod` is either a test dependency,
+      or needed by one of the extensions.

vendor/github.com/ncruces/go-sqlite3/backup.go

@@ -2,7 +2,7 @@ package sqlite3
 
 // Backup is an handle to an ongoing online backup operation.
 //
-// https://www.sqlite.org/c3ref/backup.html
+// https://sqlite.org/c3ref/backup.html
 type Backup struct {
 	c      *Conn
 	handle uint32
@@ -15,7 +15,7 @@ type Backup struct {
 // and blocks until the entire backup is complete.
 // Use [Conn.BackupInit] for incremental backup.
 //
-// https://www.sqlite.org/backup.html
+// https://sqlite.org/backup.html
 func (src *Conn) Backup(srcDB, dstURI string) error {
 	b, err := src.BackupInit(srcDB, dstURI)
 	if err != nil {
@@ -31,7 +31,7 @@ func (src *Conn) Backup(srcDB, dstURI string) error {
 // Restore opens the SQLite database file srcURI,
 // and blocks until the entire restore is complete.
 //
-// https://www.sqlite.org/backup.html
+// 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 {
@@ -52,7 +52,7 @@ func (dst *Conn) Restore(dstDB, srcURI string) error {
 // then initializes a backup that copies the contents of srcDB on the src connection
 // to the "main" database in dstURI.
 //
-// https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupinit
+// 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 {
@@ -62,7 +62,7 @@ func (src *Conn) BackupInit(srcDB, dstURI string) (*Backup, error) {
 }
 
 func (c *Conn) backupInit(dst uint32, dstName string, src uint32, srcName string) (*Backup, error) {
-	defer c.arena.reset()
+	defer c.arena.mark()()
 	dstPtr := c.arena.string(dstName)
 	srcPtr := c.arena.string(srcName)
 
@@ -71,13 +71,13 @@ func (c *Conn) backupInit(dst uint32, dstName string, src uint32, srcName string
 		other = src
 	}
 
-	r := c.call(c.api.backupInit,
+	r := c.call("sqlite3_backup_init",
 		uint64(dst), uint64(dstPtr),
 		uint64(src), uint64(srcPtr))
 	if r == 0 {
 		defer c.closeDB(other)
-		r = c.call(c.api.errcode, uint64(dst))
-		return nil, c.module.error(r, dst)
+		r = c.call("sqlite3_errcode", uint64(dst))
+		return nil, c.sqlite.error(r, dst)
 	}
 
 	return &Backup{
@@ -91,13 +91,13 @@ func (c *Conn) backupInit(dst uint32, dstName string, src uint32, srcName string
 //
 // It is safe to close a nil, zero or closed Backup.
 //
-// https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupfinish
+// https://sqlite.org/c3ref/backup_finish.html#sqlite3backupfinish
 func (b *Backup) Close() error {
 	if b == nil || b.handle == 0 {
 		return nil
 	}
 
-	r := b.c.call(b.c.api.backupFinish, uint64(b.handle))
+	r := b.c.call("sqlite3_backup_finish", uint64(b.handle))
 	b.c.closeDB(b.otherc)
 	b.handle = 0
 	return b.c.error(r)
@@ -106,9 +106,9 @@ func (b *Backup) Close() error {
 // Step copies up to nPage pages between the source and destination databases.
 // If nPage is negative, all remaining source pages are copied.
 //
-// https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupstep
+// https://sqlite.org/c3ref/backup_finish.html#sqlite3backupstep
 func (b *Backup) Step(nPage int) (done bool, err error) {
-	r := b.c.call(b.c.api.backupStep, uint64(b.handle), uint64(nPage))
+	r := b.c.call("sqlite3_backup_step", uint64(b.handle), uint64(nPage))
 	if r == _DONE {
 		return true, nil
 	}
@@ -118,17 +118,17 @@ func (b *Backup) Step(nPage int) (done bool, err error) {
 // Remaining returns the number of pages still to be backed up
 // at the conclusion of the most recent [Backup.Step].
 //
-// https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupremaining
+// https://sqlite.org/c3ref/backup_finish.html#sqlite3backupremaining
 func (b *Backup) Remaining() int {
-	r := b.c.call(b.c.api.backupRemaining, uint64(b.handle))
-	return int(r)
+	r := b.c.call("sqlite3_backup_remaining", uint64(b.handle))
+	return int(int32(r))
 }
 
 // PageCount returns the total number of pages in the source database
 // at the conclusion of the most recent [Backup.Step].
 //
-// https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backuppagecount
+// https://sqlite.org/c3ref/backup_finish.html#sqlite3backuppagecount
 func (b *Backup) PageCount() int {
-	r := b.c.call(b.c.api.backupPageCount, uint64(b.handle))
-	return int(r)
+	r := b.c.call("sqlite3_backup_pagecount", uint64(b.handle))
+	return int(int32(r))
 }

vendor/github.com/ncruces/go-sqlite3/blob.go

@@ -15,7 +15,7 @@ type ZeroBlob int64
 //
 // It implements [io.ReadWriteSeeker] for incremental BLOB I/O.
 //
-// https://www.sqlite.org/c3ref/blob.html
+// https://sqlite.org/c3ref/blob.html
 type Blob struct {
 	c      *Conn
 	bytes  int64
@@ -27,10 +27,10 @@ var _ io.ReadWriteSeeker = &Blob{}
 
 // OpenBlob opens a BLOB for incremental I/O.
 //
-// https://www.sqlite.org/c3ref/blob_open.html
+// https://sqlite.org/c3ref/blob_open.html
 func (c *Conn) OpenBlob(db, table, column string, row int64, write bool) (*Blob, error) {
 	c.checkInterrupt()
-	defer c.arena.reset()
+	defer c.arena.mark()()
 	blobPtr := c.arena.new(ptrlen)
 	dbPtr := c.arena.string(db)
 	tablePtr := c.arena.string(table)
@@ -41,7 +41,7 @@ func (c *Conn) OpenBlob(db, table, column string, row int64, write bool) (*Blob,
 		flags = 1
 	}
 
-	r := c.call(c.api.blobOpen, uint64(c.handle),
+	r := c.call("sqlite3_blob_open", uint64(c.handle),
 		uint64(dbPtr), uint64(tablePtr), uint64(columnPtr),
 		uint64(row), flags, uint64(blobPtr))
 
@@ -51,7 +51,7 @@ func (c *Conn) OpenBlob(db, table, column string, row int64, write bool) (*Blob,
 
 	blob := Blob{c: c}
 	blob.handle = util.ReadUint32(c.mod, blobPtr)
-	blob.bytes = int64(c.call(c.api.blobBytes, uint64(blob.handle)))
+	blob.bytes = int64(c.call("sqlite3_blob_bytes", uint64(blob.handle)))
 	return &blob, nil
 }
 
@@ -59,13 +59,13 @@ func (c *Conn) OpenBlob(db, table, column string, row int64, write bool) (*Blob,
 //
 // It is safe to close a nil, zero or closed Blob.
 //
-// https://www.sqlite.org/c3ref/blob_close.html
+// https://sqlite.org/c3ref/blob_close.html
 func (b *Blob) Close() error {
 	if b == nil || b.handle == 0 {
 		return nil
 	}
 
-	r := b.c.call(b.c.api.blobClose, uint64(b.handle))
+	r := b.c.call("sqlite3_blob_close", uint64(b.handle))
 
 	b.handle = 0
 	return b.c.error(r)
@@ -73,14 +73,14 @@ func (b *Blob) Close() error {
 
 // Size returns the size of the BLOB in bytes.
 //
-// https://www.sqlite.org/c3ref/blob_bytes.html
+// https://sqlite.org/c3ref/blob_bytes.html
 func (b *Blob) Size() int64 {
 	return b.bytes
 }
 
 // Read implements the [io.Reader] interface.
 //
-// https://www.sqlite.org/c3ref/blob_read.html
+// 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
@@ -92,10 +92,10 @@ func (b *Blob) Read(p []byte) (n int, err error) {
 		want = avail
 	}
 
-	defer b.c.arena.reset()
+	defer b.c.arena.mark()()
 	ptr := b.c.arena.new(uint64(want))
 
-	r := b.c.call(b.c.api.blobRead, uint64(b.handle),
+	r := b.c.call("sqlite3_blob_read", uint64(b.handle),
 		uint64(ptr), uint64(want), uint64(b.offset))
 	err = b.c.error(r)
 	if err != nil {
@@ -112,23 +112,23 @@ func (b *Blob) Read(p []byte) (n int, err error) {
 
 // WriteTo implements the [io.WriterTo] interface.
 //
-// https://www.sqlite.org/c3ref/blob_read.html
+// 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
-	want := int64(65536)
 	if want > avail {
 		want = avail
 	}
 
-	ptr := b.c.new(uint64(want))
-	defer b.c.free(ptr)
+	defer b.c.arena.mark()()
+	ptr := b.c.arena.new(uint64(want))
 
 	for want > 0 {
-		r := b.c.call(b.c.api.blobRead, uint64(b.handle),
+		r := b.c.call("sqlite3_blob_read", uint64(b.handle),
 			uint64(ptr), uint64(want), uint64(b.offset))
 		err = b.c.error(r)
 		if err != nil {
@@ -156,12 +156,12 @@ func (b *Blob) WriteTo(w io.Writer) (n int64, err error) {
 
 // Write implements the [io.Writer] interface.
 //
-// https://www.sqlite.org/c3ref/blob_write.html
+// https://sqlite.org/c3ref/blob_write.html
 func (b *Blob) Write(p []byte) (n int, err error) {
-	defer b.c.arena.reset()
+	defer b.c.arena.mark()()
 	ptr := b.c.arena.bytes(p)
 
-	r := b.c.call(b.c.api.blobWrite, uint64(b.handle),
+	r := b.c.call("sqlite3_blob_write", uint64(b.handle),
 		uint64(ptr), uint64(len(p)), uint64(b.offset))
 	err = b.c.error(r)
 	if err != nil {
@@ -173,10 +173,13 @@ func (b *Blob) Write(p []byte) (n int, err error) {
 
 // ReadFrom implements the [io.ReaderFrom] interface.
 //
-// https://www.sqlite.org/c3ref/blob_write.html
+// 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
-	want := int64(65536)
+	if l, ok := r.(*io.LimitedReader); ok && want > l.N {
+		want = l.N
+	}
 	if want > avail {
 		want = avail
 	}
@@ -184,14 +187,14 @@ func (b *Blob) ReadFrom(r io.Reader) (n int64, err error) {
 		want = 1
 	}
 
-	ptr := b.c.new(uint64(want))
-	defer b.c.free(ptr)
+	defer b.c.arena.mark()()
+	ptr := b.c.arena.new(uint64(want))
 
 	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),
+			r := b.c.call("sqlite3_blob_write", uint64(b.handle),
 				uint64(ptr), uint64(m), uint64(b.offset))
 			err := b.c.error(r)
 			if err != nil {
@@ -238,10 +241,10 @@ func (b *Blob) Seek(offset int64, whence int) (int64, error) {
 
 // Reopen moves a BLOB handle to a new row of the same database table.
 //
-// https://www.sqlite.org/c3ref/blob_reopen.html
+// https://sqlite.org/c3ref/blob_reopen.html
 func (b *Blob) Reopen(row int64) error {
-	err := b.c.error(b.c.call(b.c.api.blobReopen, uint64(b.handle), uint64(row)))
-	b.bytes = int64(b.c.call(b.c.api.blobBytes, uint64(b.handle)))
+	err := b.c.error(b.c.call("sqlite3_blob_reopen", uint64(b.handle), uint64(row)))
+	b.bytes = int64(b.c.call("sqlite3_blob_bytes", uint64(b.handle)))
 	b.offset = 0
 	return err
 }

vendor/github.com/ncruces/go-sqlite3/config.go

@@ -0,0 +1,164 @@
+package sqlite3
+
+import (
+	"context"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/tetratelabs/wazero/api"
+)
+
+// Config makes configuration changes to a database connection.
+// Only boolean configuration options are supported.
+// Called with no arg reads the current configuration value,
+// called with one arg sets and returns the new value.
+//
+// https://sqlite.org/c3ref/db_config.html
+func (c *Conn) Config(op DBConfig, arg ...bool) (bool, error) {
+	defer c.arena.mark()()
+	argsPtr := c.arena.new(2 * ptrlen)
+
+	var flag int
+	switch {
+	case len(arg) == 0:
+		flag = -1
+	case arg[0]:
+		flag = 1
+	}
+
+	util.WriteUint32(c.mod, argsPtr+0*ptrlen, uint32(flag))
+	util.WriteUint32(c.mod, argsPtr+1*ptrlen, argsPtr)
+
+	r := c.call("sqlite3_db_config", uint64(c.handle),
+		uint64(op), uint64(argsPtr))
+	return util.ReadUint32(c.mod, argsPtr) != 0, c.error(r)
+}
+
+// ConfigLog sets up the error logging callback for the connection.
+//
+// https://sqlite.org/errlog.html
+func (c *Conn) ConfigLog(cb func(code ExtendedErrorCode, msg string)) error {
+	var enable uint64
+	if cb != nil {
+		enable = 1
+	}
+	r := c.call("sqlite3_config_log_go", enable)
+	if err := c.error(r); err != nil {
+		return err
+	}
+	c.log = cb
+	return nil
+}
+
+func logCallback(ctx context.Context, mod api.Module, _, iCode, zMsg uint32) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.log != nil {
+		msg := util.ReadString(mod, zMsg, _MAX_LENGTH)
+		c.log(xErrorCode(iCode), msg)
+	}
+}
+
+// Limit allows the size of various constructs to be
+// limited on a connection by connection basis.
+//
+// https://sqlite.org/c3ref/limit.html
+func (c *Conn) Limit(id LimitCategory, value int) int {
+	r := c.call("sqlite3_limit", uint64(c.handle), uint64(id), uint64(value))
+	return int(int32(r))
+}
+
+// SetAuthorizer registers an authorizer callback with the database connection.
+//
+// https://sqlite.org/c3ref/set_authorizer.html
+func (c *Conn) SetAuthorizer(cb func(action AuthorizerActionCode, name3rd, name4th, schema, nameInner string) AuthorizerReturnCode) error {
+	var enable uint64
+	if cb != nil {
+		enable = 1
+	}
+	r := c.call("sqlite3_set_authorizer_go", uint64(c.handle), enable)
+	if err := c.error(r); err != nil {
+		return err
+	}
+	c.authorizer = cb
+	return nil
+
+}
+
+func authorizerCallback(ctx context.Context, mod api.Module, pDB uint32, action AuthorizerActionCode, zName3rd, zName4th, zSchema, zNameInner uint32) (rc AuthorizerReturnCode) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.authorizer != nil {
+		var name3rd, name4th, schema, nameInner string
+		if zName3rd != 0 {
+			name3rd = util.ReadString(mod, zName3rd, _MAX_NAME)
+		}
+		if zName4th != 0 {
+			name4th = util.ReadString(mod, zName4th, _MAX_NAME)
+		}
+		if zSchema != 0 {
+			schema = util.ReadString(mod, zSchema, _MAX_NAME)
+		}
+		if zNameInner != 0 {
+			nameInner = util.ReadString(mod, zNameInner, _MAX_NAME)
+		}
+		rc = c.authorizer(action, name3rd, name4th, schema, nameInner)
+	}
+	return rc
+}
+
+// WalCheckpoint checkpoints a WAL database.
+//
+// https://sqlite.org/c3ref/wal_checkpoint_v2.html
+func (c *Conn) WalCheckpoint(schema string, mode CheckpointMode) (nLog, nCkpt int, err error) {
+	defer c.arena.mark()()
+	nLogPtr := c.arena.new(ptrlen)
+	nCkptPtr := c.arena.new(ptrlen)
+	schemaPtr := c.arena.string(schema)
+	r := c.call("sqlite3_wal_checkpoint_v2",
+		uint64(c.handle), uint64(schemaPtr), uint64(mode),
+		uint64(nLogPtr), uint64(nCkptPtr))
+	nLog = int(int32(util.ReadUint32(c.mod, nLogPtr)))
+	nCkpt = int(int32(util.ReadUint32(c.mod, nCkptPtr)))
+	return nLog, nCkpt, c.error(r)
+}
+
+// WalAutoCheckpoint configures WAL auto-checkpoints.
+//
+// https://sqlite.org/c3ref/wal_autocheckpoint.html
+func (c *Conn) WalAutoCheckpoint(pages int) error {
+	r := c.call("sqlite3_wal_autocheckpoint", uint64(c.handle), uint64(pages))
+	return c.error(r)
+}
+
+// WalHook registers a callback function to be invoked
+// each time data is committed to a database in WAL mode.
+//
+// https://sqlite.org/c3ref/wal_hook.html
+func (c *Conn) WalHook(cb func(db *Conn, schema string, pages int) error) {
+	var enable uint64
+	if cb != nil {
+		enable = 1
+	}
+	c.call("sqlite3_wal_hook_go", uint64(c.handle), enable)
+	c.wal = cb
+}
+
+func walCallback(ctx context.Context, mod api.Module, _, pDB, zSchema uint32, pages int32) (rc uint32) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.wal != nil {
+		schema := util.ReadString(mod, zSchema, _MAX_NAME)
+		err := c.wal(c, schema, int(pages))
+		_, rc = errorCode(err, ERROR)
+	}
+	return rc
+}
+
+// AutoVacuumPages registers a autovacuum compaction amount callback.
+//
+// https://sqlite.org/c3ref/autovacuum_pages.html
+func (c *Conn) AutoVacuumPages(cb func(schema string, dbPages, freePages, bytesPerPage uint) uint) error {
+	funcPtr := util.AddHandle(c.ctx, cb)
+	r := c.call("sqlite3_autovacuum_pages_go", uint64(c.handle), uint64(funcPtr))
+	return c.error(r)
+}
+
+func autoVacuumCallback(ctx context.Context, mod api.Module, pApp, zSchema, nDbPage, nFreePage, nBytePerPage uint32) uint32 {
+	fn := util.GetHandle(ctx, pApp).(func(schema string, dbPages, freePages, bytesPerPage uint) uint)
+	schema := util.ReadString(mod, zSchema, _MAX_NAME)
+	return uint32(fn(schema, uint(nDbPage), uint(nFreePage), uint(nBytePerPage)))
+}

vendor/github.com/ncruces/go-sqlite3/conn.go

@@ -2,29 +2,35 @@ package sqlite3
 
 import (
 	"context"
-	"database/sql/driver"
-	"errors"
 	"fmt"
+	"math"
 	"net/url"
-	"runtime"
 	"strings"
-	"sync/atomic"
-	"unsafe"
+	"time"
 
 	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/ncruces/go-sqlite3/vfs"
+	"github.com/tetratelabs/wazero/api"
 )
 
 // Conn is a database connection handle.
 // A Conn is not safe for concurrent use by multiple goroutines.
 //
-// https://www.sqlite.org/c3ref/sqlite3.html
+// https://sqlite.org/c3ref/sqlite3.html
 type Conn struct {
-	*module
+	*sqlite
 
-	interrupt context.Context
-	waiter    chan struct{}
-	pending   *Stmt
-	arena     arena
+	interrupt  context.Context
+	pending    *Stmt
+	busy       func(int) bool
+	log        func(xErrorCode, string)
+	collation  func(*Conn, string)
+	authorizer func(AuthorizerActionCode, string, string, string, string) AuthorizerReturnCode
+	update     func(AuthorizerActionCode, string, string, int64)
+	commit     func() bool
+	rollback   func()
+	wal        func(*Conn, string, int) error
+	arena      arena
 
 	handle uint32
 }
@@ -39,9 +45,9 @@ func Open(filename string) (*Conn, error) {
 // If none of the required flags is used, a combination of [OPEN_READWRITE] and [OPEN_CREATE] is used.
 // If a URI filename is used, PRAGMA statements to execute can be specified using "_pragma":
 //
-//	sqlite3.Open("file:demo.db?_pragma=busy_timeout(10000)&_pragma=locking_mode(normal)")
+//	sqlite3.Open("file:demo.db?_pragma=busy_timeout(10000)")
 //
-// https://www.sqlite.org/c3ref/open.html
+// https://sqlite.org/c3ref/open.html
 func OpenFlags(filename string, flags OpenFlag) (*Conn, error) {
 	if flags&(OPEN_READONLY|OPEN_READWRITE|OPEN_CREATE) == 0 {
 		flags |= OPEN_READWRITE | OPEN_CREATE
@@ -49,21 +55,22 @@ func OpenFlags(filename string, flags OpenFlag) (*Conn, error) {
 	return newConn(filename, flags)
 }
 
+type connKey struct{}
+
 func newConn(filename string, flags OpenFlag) (conn *Conn, err error) {
-	mod, err := instantiateModule()
+	sqlite, err := instantiateSQLite()
 	if err != nil {
 		return nil, err
 	}
 	defer func() {
 		if conn == nil {
-			mod.close()
-		} else {
-			runtime.SetFinalizer(conn, util.Finalizer[Conn](3))
+			sqlite.close()
 		}
 	}()
 
-	c := &Conn{module: mod}
+	c := &Conn{sqlite: sqlite}
 	c.arena = c.newArena(1024)
+	c.ctx = context.WithValue(c.ctx, connKey{}, c)
 	c.handle, err = c.openDB(filename, flags)
 	if err != nil {
 		return nil, err
@@ -72,15 +79,15 @@ func newConn(filename string, flags OpenFlag) (conn *Conn, err error) {
 }
 
 func (c *Conn) openDB(filename string, flags OpenFlag) (uint32, error) {
-	defer c.arena.reset()
+	defer c.arena.mark()()
 	connPtr := c.arena.new(ptrlen)
 	namePtr := c.arena.string(filename)
 
 	flags |= OPEN_EXRESCODE
-	r := c.call(c.api.open, uint64(namePtr), uint64(connPtr), uint64(flags), 0)
+	r := c.call("sqlite3_open_v2", uint64(namePtr), uint64(connPtr), uint64(flags), 0)
 
 	handle := util.ReadUint32(c.mod, connPtr)
-	if err := c.module.error(r, handle); err != nil {
+	if err := c.sqlite.error(r, handle); err != nil {
 		c.closeDB(handle)
 		return 0, err
 	}
@@ -92,28 +99,26 @@ func (c *Conn) openDB(filename string, flags OpenFlag) (uint32, error) {
 			for _, p := range query["_pragma"] {
 				pragmas.WriteString(`PRAGMA `)
 				pragmas.WriteString(p)
-				pragmas.WriteByte(';')
+				pragmas.WriteString(`;`)
 			}
 		}
-
-		c.arena.reset()
-		pragmaPtr := c.arena.string(pragmas.String())
-		r := c.call(c.api.exec, uint64(handle), uint64(pragmaPtr), 0, 0, 0)
-		if err := c.module.error(r, handle, pragmas.String()); err != nil {
-			if errors.Is(err, ERROR) {
+		if pragmas.Len() != 0 {
+			pragmaPtr := c.arena.string(pragmas.String())
+			r := c.call("sqlite3_exec", uint64(handle), uint64(pragmaPtr), 0, 0, 0)
+			if err := c.sqlite.error(r, handle, pragmas.String()); err != nil {
 				err = fmt.Errorf("sqlite3: invalid _pragma: %w", err)
+				c.closeDB(handle)
+				return 0, err
 			}
-			c.closeDB(handle)
-			return 0, err
 		}
 	}
-
+	c.call("sqlite3_progress_handler_go", uint64(handle), 100)
 	return handle, nil
 }
 
 func (c *Conn) closeDB(handle uint32) {
-	r := c.call(c.api.closeZombie, uint64(handle))
-	if err := c.module.error(r, handle); err != nil {
+	r := c.call("sqlite3_close_v2", uint64(handle))
+	if err := c.sqlite.error(r, handle); err != nil {
 		panic(err)
 	}
 }
@@ -126,37 +131,35 @@ func (c *Conn) closeDB(handle uint32) {
 //
 // It is safe to close a nil, zero or closed Conn.
 //
-// https://www.sqlite.org/c3ref/close.html
+// https://sqlite.org/c3ref/close.html
 func (c *Conn) Close() error {
 	if c == nil || c.handle == 0 {
 		return nil
 	}
 
-	c.SetInterrupt(context.Background())
 	c.pending.Close()
 	c.pending = nil
 
-	r := c.call(c.api.close, uint64(c.handle))
+	r := c.call("sqlite3_close", uint64(c.handle))
 	if err := c.error(r); err != nil {
 		return err
 	}
 
 	c.handle = 0
-	runtime.SetFinalizer(c, nil)
-	return c.module.close()
+	return c.close()
 }
 
 // Exec is a convenience function that allows an application to run
 // multiple statements of SQL without having to use a lot of code.
 //
-// https://www.sqlite.org/c3ref/exec.html
+// https://sqlite.org/c3ref/exec.html
 func (c *Conn) Exec(sql string) error {
 	c.checkInterrupt()
-	defer c.arena.reset()
+	defer c.arena.mark()()
 	sqlPtr := c.arena.string(sql)
 
-	r := c.call(c.api.exec, uint64(c.handle), uint64(sqlPtr), 0, 0, 0)
-	return c.error(r)
+	r := c.call("sqlite3_exec", uint64(c.handle), uint64(sqlPtr), 0, 0, 0)
+	return c.error(r, sql)
 }
 
 // Prepare calls [Conn.PrepareFlags] with no flags.
@@ -169,25 +172,26 @@ func (c *Conn) Prepare(sql string) (stmt *Stmt, tail string, err error) {
 // If the input text contains no SQL (if the input is an empty string or a comment),
 // both stmt and err will be nil.
 //
-// https://www.sqlite.org/c3ref/prepare.html
+// https://sqlite.org/c3ref/prepare.html
 func (c *Conn) PrepareFlags(sql string, flags PrepareFlag) (stmt *Stmt, tail string, err error) {
-	if emptyStatement(sql) {
-		return nil, "", nil
+	if len(sql) > _MAX_SQL_LENGTH {
+		return nil, "", TOOBIG
 	}
 
-	defer c.arena.reset()
+	defer c.arena.mark()()
 	stmtPtr := c.arena.new(ptrlen)
 	tailPtr := c.arena.new(ptrlen)
 	sqlPtr := c.arena.string(sql)
 
-	r := c.call(c.api.prepare, uint64(c.handle),
+	r := c.call("sqlite3_prepare_v3", uint64(c.handle),
 		uint64(sqlPtr), uint64(len(sql)+1), uint64(flags),
 		uint64(stmtPtr), uint64(tailPtr))
 
 	stmt = &Stmt{c: c}
 	stmt.handle = util.ReadUint32(c.mod, stmtPtr)
-	i := util.ReadUint32(c.mod, tailPtr)
-	tail = sql[i-sqlPtr:]
+	if sql := sql[util.ReadUint32(c.mod, tailPtr)-sqlPtr:]; sql != "" {
+		tail = sql
+	}
 
 	if err := c.error(r, sql); err != nil {
 		return nil, "", err
@@ -195,36 +199,108 @@ func (c *Conn) PrepareFlags(sql string, flags PrepareFlag) (stmt *Stmt, tail str
 	if stmt.handle == 0 {
 		return nil, "", nil
 	}
-	return
+	return stmt, tail, nil
+}
+
+// DBName returns the schema name for n-th database on the database connection.
+//
+// https://sqlite.org/c3ref/db_name.html
+func (c *Conn) DBName(n int) string {
+	r := c.call("sqlite3_db_name", uint64(c.handle), uint64(n))
+
+	ptr := uint32(r)
+	if ptr == 0 {
+		return ""
+	}
+	return util.ReadString(c.mod, ptr, _MAX_NAME)
+}
+
+// Filename returns the filename for a database.
+//
+// https://sqlite.org/c3ref/db_filename.html
+func (c *Conn) Filename(schema string) *vfs.Filename {
+	var ptr uint32
+	if schema != "" {
+		defer c.arena.mark()()
+		ptr = c.arena.string(schema)
+	}
+
+	r := c.call("sqlite3_db_filename", uint64(c.handle), uint64(ptr))
+	return vfs.OpenFilename(c.ctx, c.mod, uint32(r), vfs.OPEN_MAIN_DB)
+}
+
+// ReadOnly determines if a database is read-only.
+//
+// https://sqlite.org/c3ref/db_readonly.html
+func (c *Conn) ReadOnly(schema string) (ro bool, ok bool) {
+	var ptr uint32
+	if schema != "" {
+		defer c.arena.mark()()
+		ptr = c.arena.string(schema)
+	}
+	r := c.call("sqlite3_db_readonly", uint64(c.handle), uint64(ptr))
+	return int32(r) > 0, int32(r) < 0
 }
 
 // GetAutocommit tests the connection for auto-commit mode.
 //
-// https://www.sqlite.org/c3ref/get_autocommit.html
+// https://sqlite.org/c3ref/get_autocommit.html
 func (c *Conn) GetAutocommit() bool {
-	r := c.call(c.api.autocommit, uint64(c.handle))
+	r := c.call("sqlite3_get_autocommit", uint64(c.handle))
 	return r != 0
 }
 
 // LastInsertRowID returns the rowid of the most recent successful INSERT
 // on the database connection.
 //
-// https://www.sqlite.org/c3ref/last_insert_rowid.html
+// https://sqlite.org/c3ref/last_insert_rowid.html
 func (c *Conn) LastInsertRowID() int64 {
-	r := c.call(c.api.lastRowid, uint64(c.handle))
+	r := c.call("sqlite3_last_insert_rowid", uint64(c.handle))
 	return int64(r)
 }
 
+// SetLastInsertRowID allows the application to set the value returned by
+// [Conn.LastInsertRowID].
+//
+// https://sqlite.org/c3ref/set_last_insert_rowid.html
+func (c *Conn) SetLastInsertRowID(id int64) {
+	c.call("sqlite3_set_last_insert_rowid", uint64(c.handle), uint64(id))
+}
+
 // Changes returns the number of rows modified, inserted or deleted
 // by the most recently completed INSERT, UPDATE or DELETE statement
 // on the database connection.
 //
-// https://www.sqlite.org/c3ref/changes.html
+// https://sqlite.org/c3ref/changes.html
 func (c *Conn) Changes() int64 {
-	r := c.call(c.api.changes, uint64(c.handle))
+	r := c.call("sqlite3_changes64", uint64(c.handle))
 	return int64(r)
 }
 
+// TotalChanges returns the number of rows modified, inserted or deleted
+// by all INSERT, UPDATE or DELETE statements completed
+// since the database connection was opened.
+//
+// https://sqlite.org/c3ref/total_changes.html
+func (c *Conn) TotalChanges() int64 {
+	r := c.call("sqlite3_total_changes64", uint64(c.handle))
+	return int64(r)
+}
+
+// ReleaseMemory frees memory used by a database connection.
+//
+// https://sqlite.org/c3ref/db_release_memory.html
+func (c *Conn) ReleaseMemory() error {
+	r := c.call("sqlite3_db_release_memory", uint64(c.handle))
+	return c.error(r)
+}
+
+// GetInterrupt gets the context set with [Conn.SetInterrupt],
+// or nil if none was set.
+func (c *Conn) GetInterrupt() context.Context {
+	return c.interrupt
+}
+
 // SetInterrupt interrupts a long-running query when a context is done.
 //
 // Subsequent uses of the connection will return [INTERRUPT]
@@ -238,108 +314,89 @@ func (c *Conn) Changes() int64 {
 //
 // SetInterrupt returns the old context assigned to the connection.
 //
-// https://www.sqlite.org/c3ref/interrupt.html
+// https://sqlite.org/c3ref/interrupt.html
 func (c *Conn) SetInterrupt(ctx context.Context) (old context.Context) {
-	// Is a waiter running?
-	if c.waiter != nil {
-		c.waiter <- struct{}{} // Cancel the waiter.
-		<-c.waiter             // Wait for it to finish.
-		c.waiter = nil
+	// Is it the same context?
+	if ctx == c.interrupt {
+		return ctx
 	}
-	// Reset the pending statement.
-	if c.pending != nil {
-		c.pending.Reset()
+
+	// A busy SQL statement prevents SQLite from ignoring an interrupt
+	// that comes before any other statements are started.
+	if c.pending == nil {
+		c.pending, _, _ = c.Prepare(`WITH RECURSIVE c(x) AS (VALUES(0) UNION ALL SELECT x FROM c) SELECT x FROM c`)
 	}
 
 	old = c.interrupt
 	c.interrupt = ctx
-	if ctx == nil || ctx.Done() == nil {
-		return old
+
+	if old != nil && old.Done() != nil && (ctx == nil || ctx.Err() == nil) {
+		c.pending.Reset()
 	}
-
-	// Creating an uncompleted SQL statement prevents SQLite from ignoring
-	// an interrupt that comes before any other statements are started.
-	if c.pending == nil {
-		c.pending, _, _ = c.Prepare(`SELECT 1 UNION ALL SELECT 2`)
+	if ctx != nil && ctx.Done() != nil {
+		c.pending.Step()
 	}
-	c.pending.Step()
-
-	// Don't create the goroutine if we're already interrupted.
-	// This happens frequently while restoring to a previously interrupted state.
-	if c.checkInterrupt() {
-		return old
-	}
-
-	waiter := make(chan struct{})
-	c.waiter = waiter
-	go func() {
-		select {
-		case <-waiter: // Waiter was cancelled.
-			break
-
-		case <-ctx.Done(): // Done was closed.
-			const isInterruptedOffset = 280
-			buf := util.View(c.mod, c.handle+isInterruptedOffset, 4)
-			(*atomic.Uint32)(unsafe.Pointer(&buf[0])).Store(1)
-			// Wait for the next call to SetInterrupt.
-			<-waiter
-		}
-
-		// Signal that the waiter has finished.
-		waiter <- struct{}{}
-	}()
 	return old
 }
 
-func (c *Conn) checkInterrupt() bool {
-	if c.interrupt == nil || c.interrupt.Err() == nil {
-		return false
+func (c *Conn) checkInterrupt() {
+	if c.interrupt != nil && c.interrupt.Err() != nil {
+		c.call("sqlite3_interrupt", uint64(c.handle))
 	}
-	const isInterruptedOffset = 280
-	buf := util.View(c.mod, c.handle+isInterruptedOffset, 4)
-	(*atomic.Uint32)(unsafe.Pointer(&buf[0])).Store(1)
-	return true
 }
 
-// Pragma executes a PRAGMA statement and returns any results.
-//
-// https://www.sqlite.org/pragma.html
-func (c *Conn) Pragma(str string) ([]string, error) {
-	stmt, _, err := c.Prepare(`PRAGMA ` + str)
-	if err != nil {
-		return nil, err
+func progressCallback(ctx context.Context, mod api.Module, pDB uint32) (interrupt uint32) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.interrupt != nil {
+		if c.interrupt.Err() != nil {
+			interrupt = 1
+		}
 	}
-	defer stmt.Close()
+	return interrupt
+}
 
-	var pragmas []string
-	for stmt.Step() {
-		pragmas = append(pragmas, stmt.ColumnText(0))
+// BusyTimeout sets a busy timeout.
+//
+// https://sqlite.org/c3ref/busy_timeout.html
+func (c *Conn) BusyTimeout(timeout time.Duration) error {
+	ms := min((timeout+time.Millisecond-1)/time.Millisecond, math.MaxInt32)
+	r := c.call("sqlite3_busy_timeout", uint64(c.handle), uint64(ms))
+	return c.error(r)
+}
+
+// BusyHandler registers a callback to handle [BUSY] errors.
+//
+// https://sqlite.org/c3ref/busy_handler.html
+func (c *Conn) BusyHandler(cb func(count int) (retry bool)) error {
+	var enable uint64
+	if cb != nil {
+		enable = 1
 	}
-	return pragmas, stmt.Close()
+	r := c.call("sqlite3_busy_handler_go", uint64(c.handle), enable)
+	if err := c.error(r); err != nil {
+		return err
+	}
+	c.busy = cb
+	return nil
+}
+
+func busyCallback(ctx context.Context, mod api.Module, pDB uint32, count int32) (retry uint32) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.busy != nil {
+		if c.busy(int(count)) {
+			retry = 1
+		}
+	}
+	return retry
 }
 
 func (c *Conn) error(rc uint64, sql ...string) error {
-	return c.module.error(rc, c.handle, sql...)
+	return c.sqlite.error(rc, c.handle, sql...)
 }
 
 // DriverConn is implemented by the SQLite [database/sql] driver connection.
 //
-// It can be used to access advanced SQLite features like
-// [savepoints], [online backup] and [incremental BLOB I/O].
+// It can be used to access SQLite features like [online backup].
 //
-// [savepoints]: https://www.sqlite.org/lang_savepoint.html
-// [online backup]: https://www.sqlite.org/backup.html
-// [incremental BLOB I/O]: https://www.sqlite.org/c3ref/blob_open.html
+// [online backup]: https://sqlite.org/backup.html
 type DriverConn interface {
-	driver.Conn
-	driver.ConnBeginTx
-	driver.ExecerContext
-	driver.ConnPrepareContext
-
-	SetInterrupt(ctx context.Context) (old context.Context)
-
-	Savepoint() Savepoint
-	Backup(srcDB, dstURI string) error
-	Restore(dstDB, srcURI string) error
-	OpenBlob(db, table, column string, row int64, write bool) (*Blob, error)
+	Raw() *Conn
 }

vendor/github.com/ncruces/go-sqlite3/const.go

@@ -9,16 +9,18 @@ const (
 
 	_UTF8 = 1
 
-	_MAX_STRING = 512 // Used for short strings: names, error messages…
-
+	_MAX_NAME            = 1e6 // Self-imposed limit for most NUL terminated strings.
+	_MAX_LENGTH          = 1e9
+	_MAX_SQL_LENGTH      = 1e9
 	_MAX_ALLOCATION_SIZE = 0x7ffffeff
+	_MAX_FUNCTION_ARG    = 100
 
 	ptrlen = 4
 )
 
 // ErrorCode is a result code that [Error.Code] might return.
 //
-// https://www.sqlite.org/rescode.html
+// https://sqlite.org/rescode.html
 type ErrorCode uint8
 
 const (
@@ -54,7 +56,7 @@ const (
 
 // ExtendedErrorCode is a result code that [Error.ExtendedCode] might return.
 //
-// https://www.sqlite.org/rescode.html
+// https://sqlite.org/rescode.html
 type (
 	ExtendedErrorCode uint16
 	xErrorCode        = ExtendedErrorCode
@@ -97,6 +99,7 @@ const (
 	IOERR_ROLLBACK_ATOMIC   ExtendedErrorCode = xErrorCode(IOERR) | (31 << 8)
 	IOERR_DATA              ExtendedErrorCode = xErrorCode(IOERR) | (32 << 8)
 	IOERR_CORRUPTFS         ExtendedErrorCode = xErrorCode(IOERR) | (33 << 8)
+	IOERR_IN_PAGE           ExtendedErrorCode = xErrorCode(IOERR) | (34 << 8)
 	LOCKED_SHAREDCACHE      ExtendedErrorCode = xErrorCode(LOCKED) | (1 << 8)
 	LOCKED_VTAB             ExtendedErrorCode = xErrorCode(LOCKED) | (2 << 8)
 	BUSY_RECOVERY           ExtendedErrorCode = xErrorCode(BUSY) | (1 << 8)
@@ -139,7 +142,7 @@ const (
 
 // OpenFlag is a flag for the [OpenFlags] function.
 //
-// https://www.sqlite.org/c3ref/c_open_autoproxy.html
+// https://sqlite.org/c3ref/c_open_autoproxy.html
 type OpenFlag uint32
 
 const (
@@ -158,7 +161,7 @@ const (
 
 // PrepareFlag is a flag that can be passed to [Conn.PrepareFlags].
 //
-// https://www.sqlite.org/c3ref/c_prepare_normalize.html
+// https://sqlite.org/c3ref/c_prepare_normalize.html
 type PrepareFlag uint32
 
 const (
@@ -167,9 +170,167 @@ const (
 	PREPARE_NO_VTAB    PrepareFlag = 0x04
 )
 
+// FunctionFlag is a flag that can be passed to
+// [Conn.CreateFunction] and [Conn.CreateWindowFunction].
+//
+// https://sqlite.org/c3ref/c_deterministic.html
+type FunctionFlag uint32
+
+const (
+	DETERMINISTIC  FunctionFlag = 0x000000800
+	DIRECTONLY     FunctionFlag = 0x000080000
+	SUBTYPE        FunctionFlag = 0x000100000
+	INNOCUOUS      FunctionFlag = 0x000200000
+	RESULT_SUBTYPE FunctionFlag = 0x001000000
+)
+
+// StmtStatus name counter values associated with the [Stmt.Status] method.
+//
+// https://sqlite.org/c3ref/c_stmtstatus_counter.html
+type StmtStatus uint32
+
+const (
+	STMTSTATUS_FULLSCAN_STEP StmtStatus = 1
+	STMTSTATUS_SORT          StmtStatus = 2
+	STMTSTATUS_AUTOINDEX     StmtStatus = 3
+	STMTSTATUS_VM_STEP       StmtStatus = 4
+	STMTSTATUS_REPREPARE     StmtStatus = 5
+	STMTSTATUS_RUN           StmtStatus = 6
+	STMTSTATUS_FILTER_MISS   StmtStatus = 7
+	STMTSTATUS_FILTER_HIT    StmtStatus = 8
+	STMTSTATUS_MEMUSED       StmtStatus = 99
+)
+
+// DBConfig are the available database connection configuration options.
+//
+// https://sqlite.org/c3ref/c_dbconfig_defensive.html
+type DBConfig uint32
+
+const (
+	// DBCONFIG_MAINDBNAME         DBConfig = 1000
+	// DBCONFIG_LOOKASIDE          DBConfig = 1001
+	DBCONFIG_ENABLE_FKEY           DBConfig = 1002
+	DBCONFIG_ENABLE_TRIGGER        DBConfig = 1003
+	DBCONFIG_ENABLE_FTS3_TOKENIZER DBConfig = 1004
+	DBCONFIG_ENABLE_LOAD_EXTENSION DBConfig = 1005
+	DBCONFIG_NO_CKPT_ON_CLOSE      DBConfig = 1006
+	DBCONFIG_ENABLE_QPSG           DBConfig = 1007
+	DBCONFIG_TRIGGER_EQP           DBConfig = 1008
+	DBCONFIG_RESET_DATABASE        DBConfig = 1009
+	DBCONFIG_DEFENSIVE             DBConfig = 1010
+	DBCONFIG_WRITABLE_SCHEMA       DBConfig = 1011
+	DBCONFIG_LEGACY_ALTER_TABLE    DBConfig = 1012
+	DBCONFIG_DQS_DML               DBConfig = 1013
+	DBCONFIG_DQS_DDL               DBConfig = 1014
+	DBCONFIG_ENABLE_VIEW           DBConfig = 1015
+	DBCONFIG_LEGACY_FILE_FORMAT    DBConfig = 1016
+	DBCONFIG_TRUSTED_SCHEMA        DBConfig = 1017
+	DBCONFIG_STMT_SCANSTATUS       DBConfig = 1018
+	DBCONFIG_REVERSE_SCANORDER     DBConfig = 1019
+)
+
+// LimitCategory are the available run-time limit categories.
+//
+// https://sqlite.org/c3ref/c_limit_attached.html
+type LimitCategory uint32
+
+const (
+	LIMIT_LENGTH              LimitCategory = 0
+	LIMIT_SQL_LENGTH          LimitCategory = 1
+	LIMIT_COLUMN              LimitCategory = 2
+	LIMIT_EXPR_DEPTH          LimitCategory = 3
+	LIMIT_COMPOUND_SELECT     LimitCategory = 4
+	LIMIT_VDBE_OP             LimitCategory = 5
+	LIMIT_FUNCTION_ARG        LimitCategory = 6
+	LIMIT_ATTACHED            LimitCategory = 7
+	LIMIT_LIKE_PATTERN_LENGTH LimitCategory = 8
+	LIMIT_VARIABLE_NUMBER     LimitCategory = 9
+	LIMIT_TRIGGER_DEPTH       LimitCategory = 10
+	LIMIT_WORKER_THREADS      LimitCategory = 11
+)
+
+// AuthorizerActionCode are the integer action codes
+// that the authorizer callback may be passed.
+//
+// https://sqlite.org/c3ref/c_alter_table.html
+type AuthorizerActionCode uint32
+
+const (
+	/***************************************************** 3rd ************ 4th ***********/
+	AUTH_CREATE_INDEX        AuthorizerActionCode = 1  /* Index Name      Table Name      */
+	AUTH_CREATE_TABLE        AuthorizerActionCode = 2  /* Table Name      NULL            */
+	AUTH_CREATE_TEMP_INDEX   AuthorizerActionCode = 3  /* Index Name      Table Name      */
+	AUTH_CREATE_TEMP_TABLE   AuthorizerActionCode = 4  /* Table Name      NULL            */
+	AUTH_CREATE_TEMP_TRIGGER AuthorizerActionCode = 5  /* Trigger Name    Table Name      */
+	AUTH_CREATE_TEMP_VIEW    AuthorizerActionCode = 6  /* View Name       NULL            */
+	AUTH_CREATE_TRIGGER      AuthorizerActionCode = 7  /* Trigger Name    Table Name      */
+	AUTH_CREATE_VIEW         AuthorizerActionCode = 8  /* View Name       NULL            */
+	AUTH_DELETE              AuthorizerActionCode = 9  /* Table Name      NULL            */
+	AUTH_DROP_INDEX          AuthorizerActionCode = 10 /* Index Name      Table Name      */
+	AUTH_DROP_TABLE          AuthorizerActionCode = 11 /* Table Name      NULL            */
+	AUTH_DROP_TEMP_INDEX     AuthorizerActionCode = 12 /* Index Name      Table Name      */
+	AUTH_DROP_TEMP_TABLE     AuthorizerActionCode = 13 /* Table Name      NULL            */
+	AUTH_DROP_TEMP_TRIGGER   AuthorizerActionCode = 14 /* Trigger Name    Table Name      */
+	AUTH_DROP_TEMP_VIEW      AuthorizerActionCode = 15 /* View Name       NULL            */
+	AUTH_DROP_TRIGGER        AuthorizerActionCode = 16 /* Trigger Name    Table Name      */
+	AUTH_DROP_VIEW           AuthorizerActionCode = 17 /* View Name       NULL            */
+	AUTH_INSERT              AuthorizerActionCode = 18 /* Table Name      NULL            */
+	AUTH_PRAGMA              AuthorizerActionCode = 19 /* Pragma Name     1st arg or NULL */
+	AUTH_READ                AuthorizerActionCode = 20 /* Table Name      Column Name     */
+	AUTH_SELECT              AuthorizerActionCode = 21 /* NULL            NULL            */
+	AUTH_TRANSACTION         AuthorizerActionCode = 22 /* Operation       NULL            */
+	AUTH_UPDATE              AuthorizerActionCode = 23 /* Table Name      Column Name     */
+	AUTH_ATTACH              AuthorizerActionCode = 24 /* Filename        NULL            */
+	AUTH_DETACH              AuthorizerActionCode = 25 /* Database Name   NULL            */
+	AUTH_ALTER_TABLE         AuthorizerActionCode = 26 /* Database Name   Table Name      */
+	AUTH_REINDEX             AuthorizerActionCode = 27 /* Index Name      NULL            */
+	AUTH_ANALYZE             AuthorizerActionCode = 28 /* Table Name      NULL            */
+	AUTH_CREATE_VTABLE       AuthorizerActionCode = 29 /* Table Name      Module Name     */
+	AUTH_DROP_VTABLE         AuthorizerActionCode = 30 /* Table Name      Module Name     */
+	AUTH_FUNCTION            AuthorizerActionCode = 31 /* NULL            Function Name   */
+	AUTH_SAVEPOINT           AuthorizerActionCode = 32 /* Operation       Savepoint Name  */
+	AUTH_COPY                AuthorizerActionCode = 0  /* No longer used */
+	AUTH_RECURSIVE           AuthorizerActionCode = 33 /* NULL            NULL            */
+)
+
+// AuthorizerReturnCode are the integer codes
+// that the authorizer callback may return.
+//
+// https://sqlite.org/c3ref/c_deny.html
+type AuthorizerReturnCode uint32
+
+const (
+	AUTH_OK     AuthorizerReturnCode = 0
+	AUTH_DENY   AuthorizerReturnCode = 1 /* Abort the SQL statement with an error */
+	AUTH_IGNORE AuthorizerReturnCode = 2 /* Don't allow access, but don't generate an error */
+)
+
+// CheckpointMode are all the checkpoint mode values.
+//
+// https://sqlite.org/c3ref/c_checkpoint_full.html
+type CheckpointMode uint32
+
+const (
+	CHECKPOINT_PASSIVE  CheckpointMode = 0 /* Do as much as possible w/o blocking */
+	CHECKPOINT_FULL     CheckpointMode = 1 /* Wait for writers, then checkpoint */
+	CHECKPOINT_RESTART  CheckpointMode = 2 /* Like FULL but wait for readers */
+	CHECKPOINT_TRUNCATE CheckpointMode = 3 /* Like RESTART but also truncate WAL */
+)
+
+// TxnState are the allowed return values from [Conn.TxnState].
+//
+// https://sqlite.org/c3ref/c_txn_none.html
+type TxnState uint32
+
+const (
+	TXN_NONE  TxnState = 0
+	TXN_READ  TxnState = 1
+	TXN_WRITE TxnState = 2
+)
+
 // Datatype is a fundamental datatype of SQLite.
 //
-// https://www.sqlite.org/c3ref/c_blob.html
+// https://sqlite.org/c3ref/c_blob.html
 type Datatype uint32
 
 const (
@@ -182,18 +343,18 @@ const (
 
 // String implements the [fmt.Stringer] interface.
 func (t Datatype) String() string {
-	const name = "INTEGERFLOATTEXTBLOBNULL"
+	const name = "INTEGERFLOATEXTBLOBNULL"
 	switch t {
 	case INTEGER:
 		return name[0:7]
 	case FLOAT:
 		return name[7:12]
 	case TEXT:
-		return name[12:16]
+		return name[11:15]
 	case BLOB:
-		return name[16:20]
+		return name[15:19]
 	case NULL:
-		return name[20:24]
+		return name[19:23]
 	}
 	return strconv.FormatUint(uint64(t), 10)
 }

vendor/github.com/ncruces/go-sqlite3/context.go

@@ -0,0 +1,229 @@
+package sqlite3
+
+import (
+	"encoding/json"
+	"errors"
+	"math"
+	"time"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+)
+
+// Context is the context in which an SQL function executes.
+// An SQLite [Context] is in no way related to a Go [context.Context].
+//
+// https://sqlite.org/c3ref/context.html
+type Context struct {
+	c      *Conn
+	handle uint32
+}
+
+// Conn returns the database connection of the
+// [Conn.CreateFunction] or [Conn.CreateWindowFunction]
+// routines that originally registered the application defined function.
+//
+// https://sqlite.org/c3ref/context_db_handle.html
+func (ctx Context) Conn() *Conn {
+	return ctx.c
+}
+
+// SetAuxData saves metadata for argument n of the function.
+//
+// https://sqlite.org/c3ref/get_auxdata.html
+func (ctx Context) SetAuxData(n int, data any) {
+	ptr := util.AddHandle(ctx.c.ctx, data)
+	ctx.c.call("sqlite3_set_auxdata_go", uint64(ctx.handle), uint64(n), uint64(ptr))
+}
+
+// GetAuxData returns metadata for argument n of the function.
+//
+// https://sqlite.org/c3ref/get_auxdata.html
+func (ctx Context) GetAuxData(n int) any {
+	ptr := uint32(ctx.c.call("sqlite3_get_auxdata", uint64(ctx.handle), uint64(n)))
+	return util.GetHandle(ctx.c.ctx, ptr)
+}
+
+// ResultBool sets the result of the function to a bool.
+// SQLite does not have a separate boolean storage class.
+// Instead, boolean values are stored as integers 0 (false) and 1 (true).
+//
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultBool(value bool) {
+	var i int64
+	if value {
+		i = 1
+	}
+	ctx.ResultInt64(i)
+}
+
+// ResultInt sets the result of the function to an int.
+//
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultInt(value int) {
+	ctx.ResultInt64(int64(value))
+}
+
+// ResultInt64 sets the result of the function to an int64.
+//
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultInt64(value int64) {
+	ctx.c.call("sqlite3_result_int64",
+		uint64(ctx.handle), uint64(value))
+}
+
+// ResultFloat sets the result of the function to a float64.
+//
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultFloat(value float64) {
+	ctx.c.call("sqlite3_result_double",
+		uint64(ctx.handle), math.Float64bits(value))
+}
+
+// ResultText sets the result of the function to a string.
+//
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultText(value string) {
+	ptr := ctx.c.newString(value)
+	ctx.c.call("sqlite3_result_text64",
+		uint64(ctx.handle), uint64(ptr), uint64(len(value)),
+		uint64(ctx.c.freer), _UTF8)
+}
+
+// ResultRawText sets the text result of the function to a []byte.
+//
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultRawText(value []byte) {
+	ptr := ctx.c.newBytes(value)
+	ctx.c.call("sqlite3_result_text64",
+		uint64(ctx.handle), uint64(ptr), uint64(len(value)),
+		uint64(ctx.c.freer), _UTF8)
+}
+
+// ResultBlob sets the result of the function to a []byte.
+// Returning a nil slice is the same as calling [Context.ResultNull].
+//
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultBlob(value []byte) {
+	ptr := ctx.c.newBytes(value)
+	ctx.c.call("sqlite3_result_blob64",
+		uint64(ctx.handle), uint64(ptr), uint64(len(value)),
+		uint64(ctx.c.freer))
+}
+
+// ResultZeroBlob sets the result of the function to a zero-filled, length n BLOB.
+//
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultZeroBlob(n int64) {
+	ctx.c.call("sqlite3_result_zeroblob64",
+		uint64(ctx.handle), uint64(n))
+}
+
+// ResultNull sets the result of the function to NULL.
+//
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultNull() {
+	ctx.c.call("sqlite3_result_null",
+		uint64(ctx.handle))
+}
+
+// ResultTime sets the result of the function to a [time.Time].
+//
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultTime(value time.Time, format TimeFormat) {
+	if format == TimeFormatDefault {
+		ctx.resultRFC3339Nano(value)
+		return
+	}
+	switch v := format.Encode(value).(type) {
+	case string:
+		ctx.ResultText(v)
+	case int64:
+		ctx.ResultInt64(v)
+	case float64:
+		ctx.ResultFloat(v)
+	default:
+		panic(util.AssertErr())
+	}
+}
+
+func (ctx Context) resultRFC3339Nano(value time.Time) {
+	const maxlen = uint64(len(time.RFC3339Nano)) + 5
+
+	ptr := ctx.c.new(maxlen)
+	buf := util.View(ctx.c.mod, ptr, maxlen)
+	buf = value.AppendFormat(buf[:0], time.RFC3339Nano)
+
+	ctx.c.call("sqlite3_result_text64",
+		uint64(ctx.handle), uint64(ptr), uint64(len(buf)),
+		uint64(ctx.c.freer), _UTF8)
+}
+
+// ResultPointer sets the result of the function to NULL, just like [Context.ResultNull],
+// except that it also associates ptr with that NULL value such that it can be retrieved
+// within an application-defined SQL function using [Value.Pointer].
+//
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultPointer(ptr any) {
+	valPtr := util.AddHandle(ctx.c.ctx, ptr)
+	ctx.c.call("sqlite3_result_pointer_go", uint64(valPtr))
+}
+
+// ResultJSON sets the result of the function to the JSON encoding of value.
+//
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultJSON(value any) {
+	data, err := json.Marshal(value)
+	if err != nil {
+		ctx.ResultError(err)
+		return
+	}
+	ctx.ResultRawText(data)
+}
+
+// ResultValue sets the result of the function to a copy of [Value].
+//
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultValue(value Value) {
+	if value.c != ctx.c {
+		ctx.ResultError(MISUSE)
+		return
+	}
+	ctx.c.call("sqlite3_result_value",
+		uint64(ctx.handle), uint64(value.handle))
+}
+
+// ResultError sets the result of the function an error.
+//
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultError(err error) {
+	if errors.Is(err, NOMEM) {
+		ctx.c.call("sqlite3_result_error_nomem", uint64(ctx.handle))
+		return
+	}
+
+	if errors.Is(err, TOOBIG) {
+		ctx.c.call("sqlite3_result_error_toobig", uint64(ctx.handle))
+		return
+	}
+
+	msg, code := errorCode(err, _OK)
+	if msg != "" {
+		defer ctx.c.arena.mark()()
+		ptr := ctx.c.arena.string(msg)
+		ctx.c.call("sqlite3_result_error",
+			uint64(ctx.handle), uint64(ptr), uint64(len(msg)))
+	}
+	if code != _OK {
+		ctx.c.call("sqlite3_result_error_code",
+			uint64(ctx.handle), uint64(code))
+	}
+}
+
+// VTabNoChange may return true if a column is being fetched as part
+// of an update during which the column value will not change.
+//
+// https://sqlite.org/c3ref/vtab_nochange.html
+func (ctx Context) VTabNoChange() bool {
+	r := ctx.c.call("sqlite3_vtab_nochange", uint64(ctx.handle))
+	return r != 0
+}

vendor/github.com/ncruces/go-sqlite3/driver/driver.go

@@ -12,98 +12,199 @@
 //
 //	sql.Open("sqlite3", "file:demo.db?_txlock=immediate")
 //
+// Possible values are: "deferred", "immediate", "exclusive".
+// A [read-only] transaction is always "deferred", regardless of "_txlock".
+//
+// The time encoding/decoding format can be specified using "_timefmt":
+//
+//	sql.Open("sqlite3", "file:demo.db?_timefmt=sqlite")
+//
+// Possible values are: "auto" (the default), "sqlite", "rfc3339";
+// "auto" encodes as RFC 3339 and decodes any [format] supported by SQLite;
+// "sqlite" encodes as SQLite and decodes any [format] supported by SQLite;
+// "rfc3339" encodes and decodes RFC 3339 only.
+//
 // [PRAGMA] statements can be specified using "_pragma":
 //
-//	sql.Open("sqlite3", "file:demo.db?_pragma=busy_timeout(10000)&_pragma=locking_mode(normal)")
+//	sql.Open("sqlite3", "file:demo.db?_pragma=busy_timeout(10000)")
 //
-// If no PRAGMAs are specified, a busy timeout of 1 minute
-// and normal locking mode are used.
+// If no PRAGMAs are specified, a busy timeout of 1 minute is set.
 //
 // Order matters:
 // busy timeout and locking mode should be the first PRAGMAs set, in that order.
 //
-// [URI]: https://www.sqlite.org/uri.html
-// [PRAGMA]: https://www.sqlite.org/pragma.html
-// [TRANSACTION]: https://www.sqlite.org/lang_transaction.html#deferred_immediate_and_exclusive_transactions
+// [URI]: https://sqlite.org/uri.html
+// [PRAGMA]: https://sqlite.org/pragma.html
+// [format]: https://sqlite.org/lang_datefunc.html#time_values
+// [TRANSACTION]: https://sqlite.org/lang_transaction.html#deferred_immediate_and_exclusive_transactions
+// [read-only]: https://pkg.go.dev/database/sql#TxOptions
 package driver
 
 import (
 	"context"
 	"database/sql"
 	"database/sql/driver"
+	"errors"
 	"fmt"
 	"io"
 	"net/url"
 	"strings"
 	"time"
+	"unsafe"
 
 	"github.com/ncruces/go-sqlite3"
 	"github.com/ncruces/go-sqlite3/internal/util"
 )
 
+// This variable can be replaced with -ldflags:
+//
+//	go build -ldflags="-X github.com/ncruces/go-sqlite3/driver.driverName=sqlite"
+var driverName = "sqlite3"
+
 func init() {
-	sql.Register("sqlite3", sqlite{})
+	if driverName != "" {
+		sql.Register(driverName, &SQLite{})
+	}
 }
 
-type sqlite struct{}
-
-func (sqlite) Open(name string) (_ driver.Conn, err error) {
-	var c conn
-	c.Conn, err = sqlite3.Open(name)
+// Open opens the SQLite database specified by dataSourceName as a [database/sql.DB].
+//
+// The init function is called by the driver on new connections.
+// The [sqlite3.Conn] can be used to execute queries, register functions, etc.
+// Any error returned closes the connection and is returned to [database/sql].
+func Open(dataSourceName string, init func(*sqlite3.Conn) error) (*sql.DB, error) {
+	c, err := (&SQLite{Init: init}).OpenConnector(dataSourceName)
 	if err != nil {
 		return nil, err
 	}
+	return sql.OpenDB(c), nil
+}
 
-	c.txBegin = "BEGIN"
-	var pragmas []string
+// SQLite implements [database/sql/driver.Driver].
+type SQLite struct {
+	// Init function is called by the driver on new connections.
+	// The [sqlite3.Conn] can be used to execute queries, register functions, etc.
+	// Any error returned closes the connection and is returned to [database/sql].
+	Init func(*sqlite3.Conn) error
+}
+
+// Open implements [database/sql/driver.Driver].
+func (d *SQLite) Open(name string) (driver.Conn, error) {
+	c, err := d.newConnector(name)
+	if err != nil {
+		return nil, err
+	}
+	return c.Connect(context.Background())
+}
+
+// OpenConnector implements [database/sql/driver.DriverContext].
+func (d *SQLite) OpenConnector(name string) (driver.Connector, error) {
+	return d.newConnector(name)
+}
+
+func (d *SQLite) newConnector(name string) (*connector, error) {
+	c := connector{driver: d, name: name}
+
+	var txlock, timefmt string
 	if strings.HasPrefix(name, "file:") {
 		if _, after, ok := strings.Cut(name, "?"); ok {
-			query, _ := url.ParseQuery(after)
-
-			switch s := query.Get("_txlock"); s {
-			case "":
-				c.txBegin = "BEGIN"
-			case "deferred", "immediate", "exclusive":
-				c.txBegin = "BEGIN " + s
-			default:
-				c.Close()
-				return nil, fmt.Errorf("sqlite3: invalid _txlock: %s", s)
+			query, err := url.ParseQuery(after)
+			if err != nil {
+				return nil, err
 			}
-
-			pragmas = query["_pragma"]
+			txlock = query.Get("_txlock")
+			timefmt = query.Get("_timefmt")
+			c.pragmas = query.Has("_pragma")
 		}
 	}
-	if len(pragmas) == 0 {
-		err := c.Conn.Exec(`
-			PRAGMA busy_timeout=60000;
-			PRAGMA locking_mode=normal;
-		`)
+
+	switch txlock {
+	case "":
+		c.txBegin = "BEGIN"
+	case "deferred", "immediate", "exclusive":
+		c.txBegin = "BEGIN " + txlock
+	default:
+		return nil, fmt.Errorf("sqlite3: invalid _txlock: %s", txlock)
+	}
+
+	switch timefmt {
+	case "":
+		c.tmRead = sqlite3.TimeFormatAuto
+		c.tmWrite = sqlite3.TimeFormatDefault
+	case "sqlite":
+		c.tmRead = sqlite3.TimeFormatAuto
+		c.tmWrite = sqlite3.TimeFormat3
+	case "rfc3339":
+		c.tmRead = sqlite3.TimeFormatDefault
+		c.tmWrite = sqlite3.TimeFormatDefault
+	default:
+		c.tmRead = sqlite3.TimeFormat(timefmt)
+		c.tmWrite = sqlite3.TimeFormat(timefmt)
+	}
+	return &c, nil
+}
+
+type connector struct {
+	driver  *SQLite
+	name    string
+	txBegin string
+	tmRead  sqlite3.TimeFormat
+	tmWrite sqlite3.TimeFormat
+	pragmas bool
+}
+
+func (n *connector) Driver() driver.Driver {
+	return n.driver
+}
+
+func (n *connector) Connect(ctx context.Context) (_ driver.Conn, err error) {
+	c := &conn{
+		txBegin: n.txBegin,
+		tmRead:  n.tmRead,
+		tmWrite: n.tmWrite,
+	}
+
+	c.Conn, err = sqlite3.Open(n.name)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
 		if err != nil {
 			c.Close()
-			return nil, err
 		}
-		c.reusable = true
-	} else {
-		s, _, err := c.Conn.Prepare(`
-			SELECT * FROM
-				PRAGMA_locking_mode,
-				PRAGMA_query_only;
-		`)
+	}()
+
+	old := c.Conn.SetInterrupt(ctx)
+	defer c.Conn.SetInterrupt(old)
+
+	if !n.pragmas {
+		err = c.Conn.BusyTimeout(60 * time.Second)
 		if err != nil {
-			c.Close()
 			return nil, err
 		}
-		if s.Step() {
-			c.reusable = s.ColumnText(0) == "normal"
-			c.readOnly = s.ColumnRawText(1)[0] // 0 or 1
+	}
+	if n.driver.Init != nil {
+		err = n.driver.Init(c.Conn)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if n.pragmas || n.driver.Init != nil {
+		s, _, err := c.Conn.Prepare(`PRAGMA query_only`)
+		if err != nil {
+			return nil, err
+		}
+		if s.Step() && s.ColumnBool(0) {
+			c.readOnly = '1'
+		} else {
+			c.readOnly = '0'
 		}
 		err = s.Close()
 		if err != nil {
-			c.Close()
 			return nil, err
 		}
 	}
-	return &c, nil
+	return c, nil
 }
 
 type conn struct {
@@ -111,20 +212,21 @@ type conn struct {
 	txBegin    string
 	txCommit   string
 	txRollback string
-	reusable   bool
+	tmRead     sqlite3.TimeFormat
+	tmWrite    sqlite3.TimeFormat
 	readOnly   byte
 }
 
 var (
 	// Ensure these interfaces are implemented:
-	_ driver.ExecerContext = &conn{}
-	_ driver.ConnBeginTx   = &conn{}
-	_ driver.Validator     = &conn{}
-	_ sqlite3.DriverConn   = &conn{}
+	_ driver.ConnPrepareContext = &conn{}
+	_ driver.ExecerContext      = &conn{}
+	_ driver.ConnBeginTx        = &conn{}
+	_ sqlite3.DriverConn        = &conn{}
 )
 
-func (c *conn) IsValid() bool {
-	return c.reusable
+func (c *conn) Raw() *sqlite3.Conn {
+	return c.Conn
 }
 
 func (c *conn) Begin() (driver.Tx, error) {
@@ -140,10 +242,10 @@ func (c *conn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, e
 		txBegin = `
 			BEGIN deferred;
 			PRAGMA query_only=on`
-		c.txCommit = `
+		c.txRollback = `
 			ROLLBACK;
 			PRAGMA query_only=` + string(c.readOnly)
-		c.txRollback = c.txCommit
+		c.txCommit = c.txRollback
 	}
 
 	switch opts.Isolation {
@@ -167,14 +269,20 @@ func (c *conn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, e
 
 func (c *conn) Commit() error {
 	err := c.Conn.Exec(c.txCommit)
-	if err != nil && !c.GetAutocommit() {
+	if err != nil && !c.Conn.GetAutocommit() {
 		c.Rollback()
 	}
 	return err
 }
 
 func (c *conn) Rollback() error {
-	return c.Conn.Exec(c.txRollback)
+	err := c.Conn.Exec(c.txRollback)
+	if errors.Is(err, sqlite3.INTERRUPT) {
+		old := c.Conn.SetInterrupt(context.Background())
+		defer c.Conn.SetInterrupt(old)
+		err = c.Conn.Exec(c.txRollback)
+	}
+	return err
 }
 
 func (c *conn) Prepare(query string) (driver.Stmt, error) {
@@ -190,19 +298,10 @@ func (c *conn) PrepareContext(ctx context.Context, query string) (driver.Stmt, e
 		return nil, err
 	}
 	if tail != "" {
-		// Check if the tail contains any SQL.
-		st, _, err := c.Conn.Prepare(tail)
-		if err != nil {
-			s.Close()
-			return nil, err
-		}
-		if st != nil {
-			s.Close()
-			st.Close()
-			return nil, util.TailErr
-		}
+		s.Close()
+		return nil, util.TailErr
 	}
-	return &stmt{s, c.Conn}, nil
+	return &stmt{Stmt: s, tmRead: c.tmRead, tmWrite: c.tmWrite}, nil
 }
 
 func (c *conn) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) {
@@ -211,6 +310,12 @@ func (c *conn) ExecContext(ctx context.Context, query string, args []driver.Name
 		return nil, driver.ErrSkip
 	}
 
+	if savept, ok := ctx.(*saveptCtx); ok {
+		// Called from driver.Savepoint.
+		savept.Savepoint = c.Conn.Savepoint()
+		return resultRowsAffected(0), nil
+	}
+
 	old := c.Conn.SetInterrupt(ctx)
 	defer c.Conn.SetInterrupt(old)
 
@@ -222,9 +327,14 @@ func (c *conn) ExecContext(ctx context.Context, query string, args []driver.Name
 	return newResult(c.Conn), nil
 }
 
+func (c *conn) CheckNamedValue(arg *driver.NamedValue) error {
+	return nil
+}
+
 type stmt struct {
-	Stmt *sqlite3.Stmt
-	Conn *sqlite3.Conn
+	*sqlite3.Stmt
+	tmWrite sqlite3.TimeFormat
+	tmRead  sqlite3.TimeFormat
 }
 
 var (
@@ -234,10 +344,6 @@ var (
 	_ driver.NamedValueChecker = &stmt{}
 )
 
-func (s *stmt) Close() error {
-	return s.Stmt.Close()
-}
-
 func (s *stmt) NumInput() int {
 	n := s.Stmt.BindCount()
 	for i := 1; i <= n; i++ {
@@ -259,26 +365,35 @@ func (s *stmt) Query(args []driver.Value) (driver.Rows, error) {
 }
 
 func (s *stmt) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error) {
-	// Use QueryContext to setup bindings.
-	// No need to close rows: that simply resets the statement, exec does the same.
-	_, err := s.QueryContext(ctx, args)
+	err := s.setupBindings(args)
 	if err != nil {
 		return nil, err
 	}
 
+	old := s.Stmt.Conn().SetInterrupt(ctx)
+	defer s.Stmt.Conn().SetInterrupt(old)
+
 	err = s.Stmt.Exec()
 	if err != nil {
 		return nil, err
 	}
 
-	return newResult(s.Conn), nil
+	return newResult(s.Stmt.Conn()), nil
 }
 
 func (s *stmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) {
-	err := s.Stmt.ClearBindings()
+	err := s.setupBindings(args)
 	if err != nil {
 		return nil, err
 	}
+	return &rows{ctx: ctx, stmt: s}, nil
+}
+
+func (s *stmt) setupBindings(args []driver.NamedValue) error {
+	err := s.Stmt.ClearBindings()
+	if err != nil {
+		return err
+	}
 
 	var ids [3]int
 	for _, arg := range args {
@@ -310,7 +425,11 @@ func (s *stmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driv
 			case sqlite3.ZeroBlob:
 				err = s.Stmt.BindZeroBlob(id, int64(a))
 			case time.Time:
-				err = s.Stmt.BindTime(id, a, sqlite3.TimeFormatDefault)
+				err = s.Stmt.BindTime(id, a, s.tmWrite)
+			case util.JSON:
+				err = s.Stmt.BindJSON(id, a.Value)
+			case util.PointerUnwrap:
+				err = s.Stmt.BindPointer(id, util.UnwrapPointer(a))
 			case nil:
 				err = s.Stmt.BindNull(id)
 			default:
@@ -318,17 +437,18 @@ func (s *stmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driv
 			}
 		}
 		if err != nil {
-			return nil, err
+			return err
 		}
 	}
-
-	return &rows{ctx, s.Stmt, s.Conn}, nil
+	return nil
 }
 
 func (s *stmt) CheckNamedValue(arg *driver.NamedValue) error {
 	switch arg.Value.(type) {
 	case bool, int, int64, float64, string, []byte,
-		sqlite3.ZeroBlob, time.Time, nil:
+		time.Time, sqlite3.ZeroBlob,
+		util.JSON, util.PointerUnwrap,
+		nil:
 		return nil
 	default:
 		return driver.ErrSkip
@@ -367,27 +487,52 @@ func (r resultRowsAffected) RowsAffected() (int64, error) {
 }
 
 type rows struct {
-	ctx  context.Context
-	Stmt *sqlite3.Stmt
-	Conn *sqlite3.Conn
+	ctx context.Context
+	*stmt
+	names []string
+	types []string
 }
 
 func (r *rows) Close() error {
+	r.Stmt.ClearBindings()
 	return r.Stmt.Reset()
 }
 
 func (r *rows) Columns() []string {
-	count := r.Stmt.ColumnCount()
-	columns := make([]string, count)
-	for i := range columns {
-		columns[i] = r.Stmt.ColumnName(i)
+	if r.names == nil {
+		count := r.Stmt.ColumnCount()
+		r.names = make([]string, count)
+		for i := range r.names {
+			r.names[i] = r.Stmt.ColumnName(i)
+		}
 	}
-	return columns
+	return r.names
+}
+
+func (r *rows) declType(index int) string {
+	if r.types == nil {
+		count := r.Stmt.ColumnCount()
+		r.types = make([]string, count)
+		for i := range r.types {
+			r.types[i] = strings.ToUpper(r.Stmt.ColumnDeclType(i))
+		}
+	}
+	return r.types[index]
+}
+
+func (r *rows) ColumnTypeDatabaseTypeName(index int) string {
+	decltype := r.declType(index)
+	if len := len(decltype); len > 0 && decltype[len-1] == ')' {
+		if i := strings.LastIndexByte(decltype, '('); i >= 0 {
+			decltype = decltype[:i]
+		}
+	}
+	return strings.TrimSpace(decltype)
 }
 
 func (r *rows) Next(dest []driver.Value) error {
-	old := r.Conn.SetInterrupt(r.ctx)
-	defer r.Conn.SetInterrupt(old)
+	old := r.Stmt.Conn().SetInterrupt(r.ctx)
+	defer r.Stmt.Conn().SetInterrupt(old)
 
 	if !r.Stmt.Step() {
 		if err := r.Stmt.Err(); err != nil {
@@ -396,26 +541,39 @@ func (r *rows) Next(dest []driver.Value) error {
 		return io.EOF
 	}
 
+	data := unsafe.Slice((*any)(unsafe.SliceData(dest)), len(dest))
+	err := r.Stmt.Columns(data)
 	for i := range dest {
-		switch r.Stmt.ColumnType(i) {
-		case sqlite3.INTEGER:
-			dest[i] = r.Stmt.ColumnInt64(i)
-		case sqlite3.FLOAT:
-			dest[i] = r.Stmt.ColumnFloat(i)
-		case sqlite3.BLOB:
-			dest[i] = r.Stmt.ColumnRawBlob(i)
-		case sqlite3.TEXT:
-			dest[i] = stringOrTime(r.Stmt.ColumnRawText(i))
-		case sqlite3.NULL:
-			if buf, ok := dest[i].([]byte); ok {
-				dest[i] = buf[0:0]
-			} else {
-				dest[i] = nil
+		if t, ok := r.decodeTime(i, dest[i]); ok {
+			dest[i] = t
+			continue
+		}
+		if s, ok := dest[i].(string); ok {
+			t, ok := maybeTime(s)
+			if ok {
+				dest[i] = t
 			}
-		default:
-			panic(util.AssertErr())
 		}
 	}
+	return err
+}
 
-	return r.Stmt.Err()
+func (r *rows) decodeTime(i int, v any) (_ time.Time, _ bool) {
+	if r.tmRead == sqlite3.TimeFormatDefault {
+		return
+	}
+	switch r.declType(i) {
+	case "DATE", "TIME", "DATETIME", "TIMESTAMP":
+		// maybe
+	default:
+		return
+	}
+	switch v.(type) {
+	case int64, float64, string:
+		// maybe
+	default:
+		return
+	}
+	t, err := r.tmRead.Decode(v)
+	return t, err == nil
 }

vendor/github.com/ncruces/go-sqlite3/driver/savepoint.go

@@ -0,0 +1,27 @@
+package driver
+
+import (
+	"database/sql"
+	"time"
+
+	"github.com/ncruces/go-sqlite3"
+)
+
+// Savepoint establishes a new transaction savepoint.
+//
+// https://sqlite.org/lang_savepoint.html
+func Savepoint(tx *sql.Tx) sqlite3.Savepoint {
+	var ctx saveptCtx
+	tx.ExecContext(&ctx, "")
+	return ctx.Savepoint
+}
+
+type saveptCtx struct{ sqlite3.Savepoint }
+
+func (*saveptCtx) Deadline() (deadline time.Time, ok bool) { return }
+
+func (*saveptCtx) Done() <-chan struct{} { return nil }
+
+func (*saveptCtx) Err() error { return nil }
+
+func (*saveptCtx) Value(key any) any { return nil }

vendor/github.com/ncruces/go-sqlite3/driver/time.go

@@ -1,7 +1,6 @@
 package driver
 
 import (
-	"database/sql/driver"
 	"time"
 )
 
@@ -9,23 +8,24 @@ import (
 // if it roundtrips back to the same string.
 // This way times can be persisted to, and recovered from, the database,
 // but if a string is needed, [database/sql] will recover the same string.
-func stringOrTime(text []byte) driver.Value {
+func maybeTime(text string) (_ time.Time, _ bool) {
 	// Weed out (some) values that can't possibly be
 	// [time.RFC3339Nano] timestamps.
 	if len(text) < len("2006-01-02T15:04:05Z") {
-		return string(text)
+		return
 	}
 	if len(text) > len(time.RFC3339Nano) {
-		return string(text)
+		return
 	}
 	if text[4] != '-' || text[10] != 'T' || text[16] != ':' {
-		return string(text)
+		return
 	}
 
 	// Slow path.
-	date, err := time.Parse(time.RFC3339Nano, string(text))
-	if err == nil && date.Format(time.RFC3339Nano) == string(text) {
-		return date
+	var buf [len(time.RFC3339Nano)]byte
+	date, err := time.Parse(time.RFC3339Nano, text)
+	if err == nil && text == string(date.AppendFormat(buf[:0], time.RFC3339Nano)) {
+		return date, true
 	}
-	return string(text)
+	return
 }

vendor/github.com/ncruces/go-sqlite3/embed/README.md

@@ -1,16 +1,18 @@
-# Embeddable WASM build of SQLite
+# Embeddable Wasm build of SQLite
 
-This folder includes an embeddable WASM build of SQLite 3.42.0 for use with
+This folder includes an embeddable Wasm build of SQLite 3.45.3 for use with
 [`github.com/ncruces/go-sqlite3`](https://pkg.go.dev/github.com/ncruces/go-sqlite3).
 
 The following optional features are compiled in:
-- [math functions](https://www.sqlite.org/lang_mathfunc.html)
-- [FTS3/4](https://www.sqlite.org/fts3.html)/[5](https://www.sqlite.org/fts5.html)
-- [JSON](https://www.sqlite.org/json1.html)
-- [R*Tree](https://www.sqlite.org/rtree.html)
-- [GeoPoly](https://www.sqlite.org/geopoly.html)
+- [math functions](https://sqlite.org/lang_mathfunc.html)
+- [FTS5](https://sqlite.org/fts5.html)
+- [JSON](https://sqlite.org/json1.html)
+- [R*Tree](https://sqlite.org/rtree.html)
+- [GeoPoly](https://sqlite.org/geopoly.html)
+- [soundex](https://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)
+- [ieee754](https://github.com/sqlite/sqlite/blob/master/ext/misc/ieee754.c)
 - [regexp](https://github.com/sqlite/sqlite/blob/master/ext/misc/regexp.c)
 - [series](https://github.com/sqlite/sqlite/blob/master/ext/misc/series.c)
 - [uint](https://github.com/sqlite/sqlite/blob/master/ext/misc/uint.c)

vendor/github.com/ncruces/go-sqlite3/embed/build.sh

@@ -4,24 +4,28 @@ set -euo pipefail
 cd -P -- "$(dirname -- "$0")"
 
 ROOT=../
-BINARYEN="$ROOT/tools/binaryen-version_113/bin"
-WASI_SDK="$ROOT/tools/wasi-sdk-20.0/bin"
+BINARYEN="$ROOT/tools/binaryen-version_117/bin"
+WASI_SDK="$ROOT/tools/wasi-sdk-22.0/bin"
 
-"$WASI_SDK/clang" --target=wasm32-wasi -flto -g0 -O2 \
+"$WASI_SDK/clang" --target=wasm32-wasi -std=c17 -flto -g0 -O2 \
+	-Wall -Wextra -Wno-unused-parameter \
 	-o sqlite3.wasm "$ROOT/sqlite3/main.c" \
 	-I"$ROOT/sqlite3" \
 	-mexec-model=reactor \
-	-mmutable-globals \
+	-msimd128 -mmutable-globals \
 	-mbulk-memory -mreference-types \
 	-mnontrapping-fptoint -msign-ext \
+	-fno-stack-protector -fno-stack-clash-protection \
 	-Wl,--initial-memory=327680 \
 	-Wl,--stack-first \
 	-Wl,--import-undefined \
+	-D_HAVE_SQLITE_CONFIG_H \
 	$(awk '{print "-Wl,--export="$0}' exports.txt)
 
 trap 'rm -f sqlite3.tmp' EXIT
 "$BINARYEN/wasm-ctor-eval" -g -c _initialize sqlite3.wasm -o sqlite3.tmp
-"$BINARYEN/wasm-opt" -g -O2 sqlite3.tmp -o sqlite3.wasm \
-	--enable-multivalue --enable-mutable-globals \
+"$BINARYEN/wasm-opt" -g --strip --strip-producers -c -O3 \
+	sqlite3.tmp -o sqlite3.wasm \
+	--enable-simd --enable-mutable-globals --enable-multivalue \
 	--enable-bulk-memory --enable-reference-types \
 	--enable-nontrapping-float-to-int --enable-sign-ext

vendor/github.com/ncruces/go-sqlite3/embed/exports.txt

@@ -1,49 +1,127 @@
+aligned_alloc
 free
 malloc
 malloc_destructor
-sqlite3_errcode
-sqlite3_errstr
-sqlite3_errmsg
-sqlite3_error_offset
-sqlite3_open_v2
-sqlite3_close
-sqlite3_close_v2
-sqlite3_prepare_v3
-sqlite3_finalize
-sqlite3_reset
-sqlite3_step
-sqlite3_exec
-sqlite3_clear_bindings
+sqlite3_anycollseq_init
+sqlite3_autovacuum_pages_go
+sqlite3_backup_finish
+sqlite3_backup_init
+sqlite3_backup_pagecount
+sqlite3_backup_remaining
+sqlite3_backup_step
+sqlite3_bind_blob64
+sqlite3_bind_double
+sqlite3_bind_int64
+sqlite3_bind_null
 sqlite3_bind_parameter_count
 sqlite3_bind_parameter_index
 sqlite3_bind_parameter_name
-sqlite3_bind_null
-sqlite3_bind_int64
-sqlite3_bind_double
+sqlite3_bind_pointer_go
 sqlite3_bind_text64
-sqlite3_bind_blob64
+sqlite3_bind_value
 sqlite3_bind_zeroblob64
-sqlite3_column_count
-sqlite3_column_name
-sqlite3_column_type
-sqlite3_column_int64
-sqlite3_column_double
-sqlite3_column_text
+sqlite3_blob_bytes
+sqlite3_blob_close
+sqlite3_blob_open
+sqlite3_blob_read
+sqlite3_blob_reopen
+sqlite3_blob_write
+sqlite3_busy_handler_go
+sqlite3_busy_timeout
+sqlite3_changes64
+sqlite3_clear_bindings
+sqlite3_close
+sqlite3_close_v2
+sqlite3_collation_needed_go
 sqlite3_column_blob
 sqlite3_column_bytes
-sqlite3_blob_open
-sqlite3_blob_close
-sqlite3_blob_bytes
-sqlite3_blob_read
-sqlite3_blob_write
-sqlite3_blob_reopen
-sqlite3_backup_init
-sqlite3_backup_step
-sqlite3_backup_finish
-sqlite3_backup_remaining
-sqlite3_backup_pagecount
-sqlite3_uri_parameter
-sqlite3_uri_key
-sqlite3_changes64
+sqlite3_column_count
+sqlite3_column_decltype
+sqlite3_column_double
+sqlite3_column_int64
+sqlite3_column_name
+sqlite3_column_text
+sqlite3_column_type
+sqlite3_column_value
+sqlite3_columns_go
+sqlite3_commit_hook_go
+sqlite3_config_log_go
+sqlite3_create_aggregate_function_go
+sqlite3_create_collation_go
+sqlite3_create_function_go
+sqlite3_create_module_go
+sqlite3_create_window_function_go
+sqlite3_database_file_object
+sqlite3_db_config
+sqlite3_db_filename
+sqlite3_db_name
+sqlite3_db_readonly
+sqlite3_db_release_memory
+sqlite3_declare_vtab
+sqlite3_errcode
+sqlite3_errmsg
+sqlite3_error_offset
+sqlite3_errstr
+sqlite3_exec
+sqlite3_filename_database
+sqlite3_filename_journal
+sqlite3_filename_wal
+sqlite3_finalize
+sqlite3_get_autocommit
+sqlite3_get_auxdata
+sqlite3_interrupt
 sqlite3_last_insert_rowid
-sqlite3_get_autocommit
+sqlite3_limit
+sqlite3_open_v2
+sqlite3_overload_function
+sqlite3_prepare_v3
+sqlite3_progress_handler_go
+sqlite3_reset
+sqlite3_result_blob64
+sqlite3_result_double
+sqlite3_result_error
+sqlite3_result_error_code
+sqlite3_result_error_nomem
+sqlite3_result_error_toobig
+sqlite3_result_int64
+sqlite3_result_null
+sqlite3_result_pointer_go
+sqlite3_result_text64
+sqlite3_result_value
+sqlite3_result_zeroblob64
+sqlite3_rollback_hook_go
+sqlite3_set_authorizer_go
+sqlite3_set_auxdata_go
+sqlite3_set_last_insert_rowid
+sqlite3_step
+sqlite3_stmt_busy
+sqlite3_stmt_readonly
+sqlite3_stmt_status
+sqlite3_total_changes64
+sqlite3_txn_state
+sqlite3_update_hook_go
+sqlite3_uri_key
+sqlite3_uri_parameter
+sqlite3_value_blob
+sqlite3_value_bytes
+sqlite3_value_double
+sqlite3_value_dup
+sqlite3_value_free
+sqlite3_value_int64
+sqlite3_value_nochange
+sqlite3_value_numeric_type
+sqlite3_value_pointer_go
+sqlite3_value_text
+sqlite3_value_type
+sqlite3_vtab_collation
+sqlite3_vtab_config_go
+sqlite3_vtab_distinct
+sqlite3_vtab_in
+sqlite3_vtab_in_first
+sqlite3_vtab_in_next
+sqlite3_vtab_nochange
+sqlite3_vtab_on_conflict
+sqlite3_vtab_rhs_value
+sqlite3_wal_autocheckpoint
+sqlite3_wal_checkpoint_v2
+sqlite3_wal_hook_go

vendor/github.com/ncruces/go-sqlite3/error.go

@@ -1,6 +1,7 @@
 package sqlite3
 
 import (
+	"errors"
 	"strconv"
 	"strings"
 
@@ -9,7 +10,7 @@ import (
 
 // Error wraps an SQLite Error Code.
 //
-// https://www.sqlite.org/c3ref/errcode.html
+// https://sqlite.org/c3ref/errcode.html
 type Error struct {
 	str  string
 	msg  string
@@ -19,14 +20,14 @@ type Error struct {
 
 // Code returns the primary error code for this error.
 //
-// https://www.sqlite.org/rescode.html
+// https://sqlite.org/rescode.html
 func (e *Error) Code() ErrorCode {
 	return ErrorCode(e.code)
 }
 
 // ExtendedCode returns the extended error code for this error.
 //
-// https://www.sqlite.org/rescode.html
+// https://sqlite.org/rescode.html
 func (e *Error) ExtendedCode() ExtendedErrorCode {
 	return ExtendedErrorCode(e.code)
 }
@@ -43,8 +44,7 @@ func (e *Error) Error() string {
 	}
 
 	if e.msg != "" {
-		b.WriteByte(':')
-		b.WriteByte(' ')
+		b.WriteString(": ")
 		b.WriteString(e.msg)
 	}
 
@@ -68,6 +68,19 @@ func (e *Error) Is(err error) bool {
 	return false
 }
 
+// As converts this error to an [ErrorCode] or [ExtendedErrorCode].
+func (e *Error) As(err any) bool {
+	switch c := err.(type) {
+	case *ErrorCode:
+		*c = e.Code()
+		return true
+	case *ExtendedErrorCode:
+		*c = e.ExtendedCode()
+		return true
+	}
+	return false
+}
+
 // Temporary returns true for [BUSY] errors.
 func (e *Error) Temporary() bool {
 	return e.Code() == BUSY
@@ -104,6 +117,15 @@ func (e ExtendedErrorCode) Is(err error) bool {
 	return ok && c == ErrorCode(e)
 }
 
+// As converts this error to an [ErrorCode].
+func (e ExtendedErrorCode) As(err any) bool {
+	c, ok := err.(*ErrorCode)
+	if ok {
+		*c = ErrorCode(e)
+	}
+	return ok
+}
+
 // Temporary returns true for [BUSY] errors.
 func (e ExtendedErrorCode) Temporary() bool {
 	return ErrorCode(e) == BUSY
@@ -113,3 +135,28 @@ func (e ExtendedErrorCode) Temporary() bool {
 func (e ExtendedErrorCode) Timeout() bool {
 	return e == BUSY_TIMEOUT
 }
+
+func errorCode(err error, def ErrorCode) (msg string, code uint32) {
+	switch code := err.(type) {
+	case nil:
+		return "", _OK
+	case ErrorCode:
+		return "", uint32(code)
+	case xErrorCode:
+		return "", uint32(code)
+	case *Error:
+		return code.msg, uint32(code.code)
+	}
+
+	var ecode ErrorCode
+	var xcode xErrorCode
+	switch {
+	case errors.As(err, &xcode):
+		code = uint32(xcode)
+	case errors.As(err, &ecode):
+		code = uint32(ecode)
+	default:
+		code = uint32(def)
+	}
+	return err.Error(), code
+}

vendor/github.com/ncruces/go-sqlite3/func.go

@@ -0,0 +1,214 @@
+package sqlite3
+
+import (
+	"context"
+	"sync"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/tetratelabs/wazero/api"
+)
+
+// CollationNeeded registers a callback to be invoked
+// whenever an unknown collation sequence is required.
+//
+// https://sqlite.org/c3ref/collation_needed.html
+func (c *Conn) CollationNeeded(cb func(db *Conn, name string)) error {
+	var enable uint64
+	if cb != nil {
+		enable = 1
+	}
+	r := c.call("sqlite3_collation_needed_go", uint64(c.handle), enable)
+	if err := c.error(r); err != nil {
+		return err
+	}
+	c.collation = cb
+	return nil
+}
+
+// AnyCollationNeeded uses [Conn.CollationNeeded] to register
+// a fake collating function for any unknown collating sequence.
+// The fake collating function works like BINARY.
+//
+// This can be used to load schemas that contain
+// one or more unknown collating sequences.
+func (c *Conn) AnyCollationNeeded() {
+	c.call("sqlite3_anycollseq_init", uint64(c.handle), 0, 0)
+}
+
+// CreateCollation defines a new collating sequence.
+//
+// https://sqlite.org/c3ref/create_collation.html
+func (c *Conn) CreateCollation(name string, fn func(a, b []byte) int) error {
+	defer c.arena.mark()()
+	namePtr := c.arena.string(name)
+	funcPtr := util.AddHandle(c.ctx, fn)
+	r := c.call("sqlite3_create_collation_go",
+		uint64(c.handle), uint64(namePtr), uint64(funcPtr))
+	return c.error(r)
+}
+
+// CreateFunction defines a new scalar SQL function.
+//
+// https://sqlite.org/c3ref/create_function.html
+func (c *Conn) CreateFunction(name string, nArg int, flag FunctionFlag, fn ScalarFunction) error {
+	defer c.arena.mark()()
+	namePtr := c.arena.string(name)
+	funcPtr := util.AddHandle(c.ctx, fn)
+	r := c.call("sqlite3_create_function_go",
+		uint64(c.handle), uint64(namePtr), uint64(nArg),
+		uint64(flag), uint64(funcPtr))
+	return c.error(r)
+}
+
+// ScalarFunction is the type of a scalar SQL function.
+// Implementations must not retain arg.
+type ScalarFunction func(ctx Context, arg ...Value)
+
+// CreateWindowFunction defines a new aggregate or aggregate window SQL function.
+// If fn returns a [WindowFunction], then an aggregate window function is created.
+// If fn returns an [io.Closer], it will be called to free resources.
+//
+// https://sqlite.org/c3ref/create_function.html
+func (c *Conn) CreateWindowFunction(name string, nArg int, flag FunctionFlag, fn func() AggregateFunction) error {
+	defer c.arena.mark()()
+	call := "sqlite3_create_aggregate_function_go"
+	namePtr := c.arena.string(name)
+	funcPtr := util.AddHandle(c.ctx, fn)
+	if _, ok := fn().(WindowFunction); ok {
+		call = "sqlite3_create_window_function_go"
+	}
+	r := c.call(call,
+		uint64(c.handle), uint64(namePtr), uint64(nArg),
+		uint64(flag), uint64(funcPtr))
+	return c.error(r)
+}
+
+// AggregateFunction is the interface an aggregate function should implement.
+//
+// https://sqlite.org/appfunc.html
+type AggregateFunction interface {
+	// Step is invoked to add a row to the current window.
+	// The function arguments, if any, corresponding to the row being added, are passed to Step.
+	// Implementations must not retain arg.
+	Step(ctx Context, arg ...Value)
+
+	// Value is invoked to return the current (or final) value of the aggregate.
+	Value(ctx Context)
+}
+
+// WindowFunction is the interface an aggregate window function should implement.
+//
+// https://sqlite.org/windowfunctions.html
+type WindowFunction interface {
+	AggregateFunction
+
+	// Inverse is invoked to remove the oldest presently aggregated result of Step from the current window.
+	// The function arguments, if any, are those passed to Step for the row being removed.
+	// Implementations must not retain arg.
+	Inverse(ctx Context, arg ...Value)
+}
+
+// OverloadFunction overloads a function for a virtual table.
+//
+// https://sqlite.org/c3ref/overload_function.html
+func (c *Conn) OverloadFunction(name string, nArg int) error {
+	defer c.arena.mark()()
+	namePtr := c.arena.string(name)
+	r := c.call("sqlite3_overload_function",
+		uint64(c.handle), uint64(namePtr), uint64(nArg))
+	return c.error(r)
+}
+
+func destroyCallback(ctx context.Context, mod api.Module, pApp uint32) {
+	util.DelHandle(ctx, pApp)
+}
+
+func collationCallback(ctx context.Context, mod api.Module, pArg, pDB, eTextRep, zName uint32) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.collation != nil {
+		name := util.ReadString(mod, zName, _MAX_NAME)
+		c.collation(c, name)
+	}
+}
+
+func compareCallback(ctx context.Context, mod api.Module, pApp, nKey1, pKey1, nKey2, pKey2 uint32) uint32 {
+	fn := util.GetHandle(ctx, pApp).(func(a, b []byte) int)
+	return uint32(fn(util.View(mod, pKey1, uint64(nKey1)), util.View(mod, pKey2, uint64(nKey2))))
+}
+
+func funcCallback(ctx context.Context, mod api.Module, pCtx, pApp, nArg, pArg uint32) {
+	args := getFuncArgs()
+	defer putFuncArgs(args)
+	db := ctx.Value(connKey{}).(*Conn)
+	fn := util.GetHandle(db.ctx, pApp).(ScalarFunction)
+	callbackArgs(db, args[:nArg], pArg)
+	fn(Context{db, pCtx}, args[:nArg]...)
+}
+
+func stepCallback(ctx context.Context, mod api.Module, pCtx, pAgg, pApp, nArg, pArg uint32) {
+	args := getFuncArgs()
+	defer putFuncArgs(args)
+	db := ctx.Value(connKey{}).(*Conn)
+	callbackArgs(db, args[:nArg], pArg)
+	fn, _ := callbackAggregate(db, pAgg, pApp)
+	fn.Step(Context{db, pCtx}, args[:nArg]...)
+}
+
+func finalCallback(ctx context.Context, mod api.Module, pCtx, pAgg, pApp uint32) {
+	db := ctx.Value(connKey{}).(*Conn)
+	fn, handle := callbackAggregate(db, pAgg, pApp)
+	fn.Value(Context{db, pCtx})
+	util.DelHandle(ctx, handle)
+}
+
+func valueCallback(ctx context.Context, mod api.Module, pCtx, pAgg uint32) {
+	db := ctx.Value(connKey{}).(*Conn)
+	fn := util.GetHandle(db.ctx, pAgg).(AggregateFunction)
+	fn.Value(Context{db, pCtx})
+}
+
+func inverseCallback(ctx context.Context, mod api.Module, pCtx, pAgg, nArg, pArg uint32) {
+	args := getFuncArgs()
+	defer putFuncArgs(args)
+	db := ctx.Value(connKey{}).(*Conn)
+	callbackArgs(db, args[:nArg], pArg)
+	fn := util.GetHandle(db.ctx, pAgg).(WindowFunction)
+	fn.Inverse(Context{db, pCtx}, args[:nArg]...)
+}
+
+func callbackAggregate(db *Conn, pAgg, pApp uint32) (AggregateFunction, uint32) {
+	if pApp == 0 {
+		handle := util.ReadUint32(db.mod, pAgg)
+		return util.GetHandle(db.ctx, handle).(AggregateFunction), handle
+	}
+
+	// We need to create the aggregate.
+	fn := util.GetHandle(db.ctx, pApp).(func() AggregateFunction)()
+	handle := util.AddHandle(db.ctx, fn)
+	if pAgg != 0 {
+		util.WriteUint32(db.mod, pAgg, handle)
+	}
+	return fn, handle
+}
+
+func callbackArgs(db *Conn, arg []Value, pArg uint32) {
+	for i := range arg {
+		arg[i] = Value{
+			c:      db,
+			handle: util.ReadUint32(db.mod, pArg+ptrlen*uint32(i)),
+		}
+	}
+}
+
+var funcArgsPool sync.Pool
+
+func putFuncArgs(p *[_MAX_FUNCTION_ARG]Value) {
+	funcArgsPool.Put(p)
+}
+
+func getFuncArgs() *[_MAX_FUNCTION_ARG]Value {
+	if p := funcArgsPool.Get(); p == nil {
+		return new([_MAX_FUNCTION_ARG]Value)
+	} else {
+		return p.(*[_MAX_FUNCTION_ARG]Value)
+	}
+}

vendor/github.com/ncruces/go-sqlite3/go.work

@@ -0,0 +1,6 @@
+go 1.21
+
+use (
+	.
+	./gormlite
+)

vendor/github.com/ncruces/go-sqlite3/go.work.sum

@@ -0,0 +1,8 @@
+golang.org/x/mod v0.8.0 h1:LUYupSeNrTNCGzR/hVBk2NHZO4hXcVaW1k4Qx7rjPx8=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=
+golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
+golang.org/x/term v0.19.0 h1:+ThwsDv+tYfnJFhF4L8jITxu1tdTWRTZpdsWgEgjL6Q=
+golang.org/x/term v0.19.0/go.mod h1:2CuTdWZ7KHSQwUzKva0cbMg6q2DMI3Mmxp+gKJbskEk=
+golang.org/x/tools v0.6.0 h1:BOw41kyTf3PuCW1pVQf8+Cyg8pMlkYB1oo9iJ6D/lKM=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=

vendor/github.com/ncruces/go-sqlite3/internal/util/alloc.go

@@ -0,0 +1,71 @@
+//go:build unix
+
+package util
+
+import (
+	"math"
+
+	"github.com/tetratelabs/wazero/experimental"
+	"golang.org/x/sys/unix"
+)
+
+func mmappedAllocator(cap, max uint64) experimental.LinearMemory {
+	// Round up to the page size.
+	rnd := uint64(unix.Getpagesize() - 1)
+	max = (max + rnd) &^ rnd
+	cap = (cap + rnd) &^ rnd
+
+	if max > math.MaxInt {
+		// This ensures int(max) overflows to a negative value,
+		// and unix.Mmap returns EINVAL.
+		max = math.MaxUint64
+	}
+	// Reserve max bytes of address space, to ensure we won't need to move it.
+	// A protected, private, anonymous mapping should not commit memory.
+	b, err := unix.Mmap(-1, 0, int(max), unix.PROT_NONE, unix.MAP_PRIVATE|unix.MAP_ANON)
+	if err != nil {
+		panic(err)
+	}
+	// Commit the initial cap bytes of memory.
+	err = unix.Mprotect(b[:cap], unix.PROT_READ|unix.PROT_WRITE)
+	if err != nil {
+		unix.Munmap(b)
+		panic(err)
+	}
+	return &mmappedMemory{buf: b[:cap]}
+}
+
+// The slice covers the entire mmapped memory:
+//   - len(buf) is the already committed memory,
+//   - cap(buf) is the reserved address space.
+type mmappedMemory struct {
+	buf []byte
+}
+
+func (m *mmappedMemory) Reallocate(size uint64) []byte {
+	if com := uint64(len(m.buf)); com < size {
+		// Round up to the page size.
+		rnd := uint64(unix.Getpagesize() - 1)
+		new := (size + rnd) &^ rnd
+
+		// Commit additional memory up to new bytes.
+		err := unix.Mprotect(m.buf[com:new], unix.PROT_READ|unix.PROT_WRITE)
+		if err != nil {
+			panic(err)
+		}
+
+		// Update committed memory.
+		m.buf = m.buf[:new]
+	}
+	// Limit returned capacity because bytes beyond
+	// len(m.buf) have not yet been committed.
+	return m.buf[:size:len(m.buf)]
+}
+
+func (m *mmappedMemory) Free() {
+	err := unix.Munmap(m.buf[:cap(m.buf)])
+	if err != nil {
+		panic(err)
+	}
+	m.buf = nil
+}

vendor/github.com/ncruces/go-sqlite3/internal/util/const.go

@@ -72,6 +72,7 @@ const (
 	IOERR_ROLLBACK_ATOMIC   = IOERR | (31 << 8)
 	IOERR_DATA              = IOERR | (32 << 8)
 	IOERR_CORRUPTFS         = IOERR | (33 << 8)
+	IOERR_IN_PAGE           = IOERR | (34 << 8)
 	LOCKED_SHAREDCACHE      = LOCKED | (1 << 8)
 	LOCKED_VTAB             = LOCKED | (2 << 8)
 	BUSY_RECOVERY           = BUSY | (1 << 8)

vendor/github.com/ncruces/go-sqlite3/internal/util/error.go

@@ -1,7 +1,6 @@
 package util
 
 import (
-	"fmt"
 	"runtime"
 	"strconv"
 )
@@ -15,14 +14,14 @@ const (
 	OOMErr       = ErrorString("sqlite3: out of memory")
 	RangeErr     = ErrorString("sqlite3: index out of range")
 	NoNulErr     = ErrorString("sqlite3: missing NUL terminator")
-	NoGlobalErr  = ErrorString("sqlite3: could not find global: ")
-	NoFuncErr    = ErrorString("sqlite3: could not find function: ")
-	BinaryErr    = ErrorString("sqlite3: no SQLite binary embed/set/loaded")
+	NoBinaryErr  = ErrorString("sqlite3: no SQLite binary embed/set/loaded")
+	BadBinaryErr = ErrorString("sqlite3: invalid SQLite binary embed/set/loaded")
 	TimeErr      = ErrorString("sqlite3: invalid time value")
 	WhenceErr    = ErrorString("sqlite3: invalid whence")
 	OffsetErr    = ErrorString("sqlite3: invalid offset")
 	TailErr      = ErrorString("sqlite3: multiple statements")
 	IsolationErr = ErrorString("sqlite3: unsupported isolation level")
+	ValueErr     = ErrorString("sqlite3: unsupported value")
 	NoVFSErr     = ErrorString("sqlite3: no such vfs: ")
 )
 
@@ -34,14 +33,6 @@ func AssertErr() ErrorString {
 	return ErrorString(msg)
 }
 
-func Finalizer[T any](skip int) func(*T) {
-	msg := fmt.Sprintf("sqlite3: %T not closed", new(T))
-	if _, file, line, ok := runtime.Caller(skip + 1); ok && skip >= 0 {
-		msg += " (" + file + ":" + strconv.Itoa(line) + ")"
-	}
-	return func(*T) { panic(ErrorString(msg)) }
-}
-
 func ErrorCodeString(rc uint32) string {
 	switch rc {
 	case ABORT_ROLLBACK:

vendor/github.com/ncruces/go-sqlite3/internal/util/func.go

@@ -10,6 +10,84 @@ import (
 type i32 interface{ ~int32 | ~uint32 }
 type i64 interface{ ~int64 | ~uint64 }
 
+type funcVI[T0 i32] func(context.Context, api.Module, T0)
+
+func (fn funcVI[T0]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	fn(ctx, mod, T0(stack[0]))
+}
+
+func ExportFuncVI[T0 i32](mod wazero.HostModuleBuilder, name string, fn func(context.Context, api.Module, T0)) {
+	mod.NewFunctionBuilder().
+		WithGoModuleFunction(funcVI[T0](fn),
+			[]api.ValueType{api.ValueTypeI32}, nil).
+		Export(name)
+}
+
+type funcVII[T0, T1 i32] func(context.Context, api.Module, T0, T1)
+
+func (fn funcVII[T0, T1]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	fn(ctx, mod, T0(stack[0]), T1(stack[1]))
+}
+
+func ExportFuncVII[T0, T1 i32](mod wazero.HostModuleBuilder, name string, fn func(context.Context, api.Module, T0, T1)) {
+	mod.NewFunctionBuilder().
+		WithGoModuleFunction(funcVII[T0, T1](fn),
+			[]api.ValueType{api.ValueTypeI32, api.ValueTypeI32}, nil).
+		Export(name)
+}
+
+type funcVIII[T0, T1, T2 i32] func(context.Context, api.Module, T0, T1, T2)
+
+func (fn funcVIII[T0, T1, T2]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]))
+}
+
+func ExportFuncVIII[T0, T1, T2 i32](mod wazero.HostModuleBuilder, name string, fn func(context.Context, api.Module, T0, T1, T2)) {
+	mod.NewFunctionBuilder().
+		WithGoModuleFunction(funcVIII[T0, T1, T2](fn),
+			[]api.ValueType{api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32}, nil).
+		Export(name)
+}
+
+type funcVIIII[T0, T1, T2, T3 i32] func(context.Context, api.Module, T0, T1, T2, T3)
+
+func (fn funcVIIII[T0, T1, T2, T3]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]), T3(stack[3]))
+}
+
+func ExportFuncVIIII[T0, T1, T2, T3 i32](mod wazero.HostModuleBuilder, name string, fn func(context.Context, api.Module, T0, T1, T2, T3)) {
+	mod.NewFunctionBuilder().
+		WithGoModuleFunction(funcVIIII[T0, T1, T2, T3](fn),
+			[]api.ValueType{api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32}, nil).
+		Export(name)
+}
+
+type funcVIIIII[T0, T1, T2, T3, T4 i32] func(context.Context, api.Module, T0, T1, T2, T3, T4)
+
+func (fn funcVIIIII[T0, T1, T2, T3, T4]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]), T3(stack[3]), T4(stack[4]))
+}
+
+func ExportFuncVIIIII[T0, T1, T2, T3, T4 i32](mod wazero.HostModuleBuilder, name string, fn func(context.Context, api.Module, T0, T1, T2, T3, T4)) {
+	mod.NewFunctionBuilder().
+		WithGoModuleFunction(funcVIIIII[T0, T1, T2, T3, T4](fn),
+			[]api.ValueType{api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32}, nil).
+		Export(name)
+}
+
+type funcVIIIIJ[T0, T1, T2, T3 i32, T4 i64] func(context.Context, api.Module, T0, T1, T2, T3, T4)
+
+func (fn funcVIIIIJ[T0, T1, T2, T3, T4]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]), T3(stack[3]), T4(stack[4]))
+}
+
+func ExportFuncVIIIIJ[T0, T1, T2, T3 i32, T4 i64](mod wazero.HostModuleBuilder, name string, fn func(context.Context, api.Module, T0, T1, T2, T3, T4)) {
+	mod.NewFunctionBuilder().
+		WithGoModuleFunction(funcVIIIIJ[T0, T1, T2, T3, T4](fn),
+			[]api.ValueType{api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI64}, nil).
+		Export(name)
+}
+
 type funcII[TR, T0 i32] func(context.Context, api.Module, T0) TR
 
 func (fn funcII[TR, T0]) Call(ctx context.Context, mod api.Module, stack []uint64) {
@@ -75,6 +153,19 @@ func ExportFuncIIIIII[TR, T0, T1, T2, T3, T4 i32](mod wazero.HostModuleBuilder,
 		Export(name)
 }
 
+type funcIIIIIII[TR, T0, T1, T2, T3, T4, T5 i32] func(context.Context, api.Module, T0, T1, T2, T3, T4, T5) TR
+
+func (fn funcIIIIIII[TR, T0, T1, T2, T3, T4, T5]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]), T3(stack[3]), T4(stack[4]), T5(stack[5])))
+}
+
+func ExportFuncIIIIIII[TR, T0, T1, T2, T3, T4, T5 i32](mod wazero.HostModuleBuilder, name string, fn func(context.Context, api.Module, T0, T1, T2, T3, T4, T5) TR) {
+	mod.NewFunctionBuilder().
+		WithGoModuleFunction(funcIIIIIII[TR, T0, T1, T2, T3, T4, T5](fn),
+			[]api.ValueType{api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32}, []api.ValueType{api.ValueTypeI32}).
+		Export(name)
+}
+
 type funcIIIIJ[TR, T0, T1, T2 i32, T3 i64] func(context.Context, api.Module, T0, T1, T2, T3) TR
 
 func (fn funcIIIIJ[TR, T0, T1, T2, T3]) Call(ctx context.Context, mod api.Module, stack []uint64) {

vendor/github.com/ncruces/go-sqlite3/internal/util/handle.go

@@ -0,0 +1,65 @@
+package util
+
+import (
+	"context"
+	"io"
+)
+
+type handleState struct {
+	handles []any
+	holes   int
+}
+
+func (s *handleState) CloseNotify(ctx context.Context, exitCode uint32) {
+	for _, h := range s.handles {
+		if c, ok := h.(io.Closer); ok {
+			c.Close()
+		}
+	}
+	s.handles = nil
+	s.holes = 0
+}
+
+func GetHandle(ctx context.Context, id uint32) any {
+	if id == 0 {
+		return nil
+	}
+	s := ctx.Value(moduleKey{}).(*moduleState)
+	return s.handles[^id]
+}
+
+func DelHandle(ctx context.Context, id uint32) error {
+	if id == 0 {
+		return nil
+	}
+	s := ctx.Value(moduleKey{}).(*moduleState)
+	a := s.handles[^id]
+	s.handles[^id] = nil
+	s.holes++
+	if c, ok := a.(io.Closer); ok {
+		return c.Close()
+	}
+	return nil
+}
+
+func AddHandle(ctx context.Context, a any) (id uint32) {
+	if a == nil {
+		panic(NilErr)
+	}
+	s := ctx.Value(moduleKey{}).(*moduleState)
+
+	// Find an empty slot.
+	if s.holes > cap(s.handles)-len(s.handles) {
+		for id, h := range s.handles {
+			if h == nil {
+				s.holes--
+				s.handles[id] = a
+				return ^uint32(id)
+			}
+		}
+	}
+
+	// Add a new slot.
+	s.handles = append(s.handles, a)
+	return -uint32(len(s.handles))
+}

vendor/github.com/ncruces/go-sqlite3/internal/util/json.go

@@ -0,0 +1,35 @@
+package util
+
+import (
+	"encoding/json"
+	"strconv"
+	"time"
+	"unsafe"
+)
+
+type JSON struct{ Value any }
+
+func (j JSON) Scan(value any) error {
+	var buf []byte
+
+	switch v := value.(type) {
+	case []byte:
+		buf = v
+	case string:
+		buf = unsafe.Slice(unsafe.StringData(v), len(v))
+	case int64:
+		buf = strconv.AppendInt(nil, v, 10)
+	case float64:
+		buf = strconv.AppendFloat(nil, v, 'g', -1, 64)
+	case time.Time:
+		buf = append(buf, '"')
+		buf = v.AppendFormat(buf, time.RFC3339Nano)
+		buf = append(buf, '"')
+	case nil:
+		buf = append(buf, "null"...)
+	default:
+		panic(AssertErr())
+	}
+
+	return json.Unmarshal(buf, j.Value)
+}

vendor/github.com/ncruces/go-sqlite3/internal/util/mem.go

@@ -14,6 +14,9 @@ func View(mod api.Module, ptr uint32, size uint64) []byte {
 	if size > math.MaxUint32 {
 		panic(RangeErr)
 	}
+	if size == 0 {
+		return nil
+	}
 	buf, ok := mod.Memory().Read(ptr, uint32(size))
 	if !ok {
 		panic(RangeErr)
@@ -21,6 +24,17 @@ func View(mod api.Module, ptr uint32, size uint64) []byte {
 	return buf
 }
 
+func ReadUint8(mod api.Module, ptr uint32) uint8 {
+	if ptr == 0 {
+		panic(NilErr)
+	}
+	v, ok := mod.Memory().ReadByte(ptr)
+	if !ok {
+		panic(RangeErr)
+	}
+	return v
+}
+
 func ReadUint32(mod api.Module, ptr uint32) uint32 {
 	if ptr == 0 {
 		panic(NilErr)
@@ -32,6 +46,16 @@ func ReadUint32(mod api.Module, ptr uint32) uint32 {
 	return v
 }
 
+func WriteUint8(mod api.Module, ptr uint32, v uint8) {
+	if ptr == 0 {
+		panic(NilErr)
+	}
+	ok := mod.Memory().WriteByte(ptr, v)
+	if !ok {
+		panic(RangeErr)
+	}
+}
+
 func WriteUint32(mod api.Module, ptr uint32, v uint32) {
 	if ptr == 0 {
 		panic(NilErr)

vendor/github.com/ncruces/go-sqlite3/internal/util/mmap.go

@@ -0,0 +1,97 @@
+//go:build (darwin || linux) && (amd64 || arm64 || riscv64) && !(sqlite3_flock || sqlite3_noshm || sqlite3_nosys)
+
+package util
+
+import (
+	"context"
+	"os"
+	"unsafe"
+
+	"github.com/tetratelabs/wazero/api"
+	"github.com/tetratelabs/wazero/experimental"
+	"golang.org/x/sys/unix"
+)
+
+func withMmappedAllocator(ctx context.Context) context.Context {
+	return experimental.WithMemoryAllocator(ctx,
+		experimental.MemoryAllocatorFunc(mmappedAllocator))
+}
+
+type mmapState struct {
+	regions []*MappedRegion
+}
+
+func (s *mmapState) new(ctx context.Context, mod api.Module, size int32) *MappedRegion {
+	// Find unused region.
+	for _, r := range s.regions {
+		if !r.used && r.size == size {
+			return r
+		}
+	}
+
+	// Allocate page aligned memmory.
+	alloc := mod.ExportedFunction("aligned_alloc")
+	stack := [2]uint64{
+		uint64(unix.Getpagesize()),
+		uint64(size),
+	}
+	if err := alloc.CallWithStack(ctx, stack[:]); err != nil {
+		panic(err)
+	}
+	if stack[0] == 0 {
+		panic(OOMErr)
+	}
+
+	// Save the newly allocated region.
+	ptr := uint32(stack[0])
+	buf := View(mod, ptr, uint64(size))
+	addr := uintptr(unsafe.Pointer(&buf[0]))
+	s.regions = append(s.regions, &MappedRegion{
+		Ptr:  ptr,
+		addr: addr,
+		size: size,
+	})
+	return s.regions[len(s.regions)-1]
+}
+
+type MappedRegion struct {
+	addr uintptr
+	Ptr  uint32
+	size int32
+	used bool
+}
+
+func MapRegion(ctx context.Context, mod api.Module, f *os.File, offset int64, size int32, prot int) (*MappedRegion, error) {
+	s := ctx.Value(moduleKey{}).(*moduleState)
+	r := s.new(ctx, mod, size)
+	err := r.mmap(f, offset, prot)
+	if err != nil {
+		return nil, err
+	}
+	return r, nil
+}
+
+func (r *MappedRegion) Unmap() error {
+	// We can't munmap the region, otherwise it could be remaped.
+	// Instead, convert it to a protected, private, anonymous mapping.
+	// If successful, it can be reused for a subsequent mmap.
+	_, err := mmap(r.addr, uintptr(r.size),
+		unix.PROT_NONE, unix.MAP_PRIVATE|unix.MAP_ANON|unix.MAP_FIXED,
+		-1, 0)
+	r.used = err != nil
+	return err
+}
+
+func (r *MappedRegion) mmap(f *os.File, offset int64, prot int) error {
+	_, err := mmap(r.addr, uintptr(r.size),
+		prot, unix.MAP_SHARED|unix.MAP_FIXED,
+		int(f.Fd()), offset)
+	r.used = err == nil
+	return err
+}
+
+// We need the low level mmap for MAP_FIXED to work.
+// Bind the syscall version hoping that it is more stable.
+
+//go:linkname mmap syscall.mmap
+func mmap(addr, length uintptr, prot, flag, fd int, pos int64) (*byte, error)

vendor/github.com/ncruces/go-sqlite3/internal/util/mmap_other.go

@@ -0,0 +1,11 @@
+//go:build !(darwin || linux) || !(amd64 || arm64 || riscv64) || sqlite3_flock || sqlite3_noshm || sqlite3_nosys
+
+package util
+
+import "context"
+
+type mmapState struct{}
+
+func withMmappedAllocator(ctx context.Context) context.Context {
+	return ctx
+}

vendor/github.com/ncruces/go-sqlite3/internal/util/module.go

@@ -0,0 +1,21 @@
+package util
+
+import (
+	"context"
+
+	"github.com/tetratelabs/wazero/experimental"
+)
+
+type moduleKey struct{}
+type moduleState struct {
+	mmapState
+	handleState
+}
+
+func NewContext(ctx context.Context) context.Context {
+	state := new(moduleState)
+	ctx = withMmappedAllocator(ctx)
+	ctx = experimental.WithCloseNotifier(ctx, state)
+	ctx = context.WithValue(ctx, moduleKey{}, state)
+	return ctx
+}

vendor/github.com/ncruces/go-sqlite3/internal/util/pointer.go

@@ -0,0 +1,11 @@
+package util
+
+type Pointer[T any] struct{ Value T }
+
+func (p Pointer[T]) unwrap() any { return p.Value }
+
+type PointerUnwrap interface{ unwrap() any }
+
+func UnwrapPointer(p PointerUnwrap) any {
+	return p.unwrap()
+}

vendor/github.com/ncruces/go-sqlite3/internal/util/reflect.go

@@ -0,0 +1,10 @@
+package util
+
+import "reflect"
+
+func ReflectType(v reflect.Value) reflect.Type {
+	if v.Kind() != reflect.Invalid {
+		return v.Type()
+	}
+	return nil
+}

vendor/github.com/ncruces/go-sqlite3/json.go

@@ -0,0 +1,11 @@
+package sqlite3
+
+import "github.com/ncruces/go-sqlite3/internal/util"
+
+// JSON returns a value that can be used as an argument to
+// [database/sql.DB.Exec], [database/sql.Row.Scan] and similar methods to
+// store value as JSON, or decode JSON into value.
+// JSON should NOT be used with [BindJSON] or [ResultJSON].
+func JSON(value any) any {
+	return util.JSON{Value: value}
+}

vendor/github.com/ncruces/go-sqlite3/module.go

@@ -1,352 +0,0 @@
-// Package sqlite3 wraps the C SQLite API.
-package sqlite3
-
-import (
-	"context"
-	"io"
-	"math"
-	"os"
-	"sync"
-
-	"github.com/ncruces/go-sqlite3/internal/util"
-	"github.com/ncruces/go-sqlite3/vfs"
-	"github.com/tetratelabs/wazero"
-	"github.com/tetratelabs/wazero/api"
-)
-
-// Configure SQLite WASM.
-//
-// Importing package embed initializes these
-// with an appropriate build of SQLite:
-//
-//	import _ "github.com/ncruces/go-sqlite3/embed"
-var (
-	Binary []byte // WASM binary to load.
-	Path   string // Path to load the binary from.
-)
-
-var sqlite3 struct {
-	runtime  wazero.Runtime
-	compiled wazero.CompiledModule
-	err      error
-	once     sync.Once
-}
-
-func instantiateModule() (*module, error) {
-	ctx := context.Background()
-
-	sqlite3.once.Do(compileModule)
-	if sqlite3.err != nil {
-		return nil, sqlite3.err
-	}
-
-	cfg := wazero.NewModuleConfig()
-
-	mod, err := sqlite3.runtime.InstantiateModule(ctx, sqlite3.compiled, cfg)
-	if err != nil {
-		return nil, err
-	}
-	return newModule(mod)
-}
-
-func compileModule() {
-	ctx := context.Background()
-	sqlite3.runtime = wazero.NewRuntime(ctx)
-
-	env := vfs.ExportHostFunctions(sqlite3.runtime.NewHostModuleBuilder("env"))
-	_, sqlite3.err = env.Instantiate(ctx)
-	if sqlite3.err != nil {
-		return
-	}
-
-	bin := Binary
-	if bin == nil && Path != "" {
-		bin, sqlite3.err = os.ReadFile(Path)
-		if sqlite3.err != nil {
-			return
-		}
-	}
-	if bin == nil {
-		sqlite3.err = util.BinaryErr
-		return
-	}
-
-	sqlite3.compiled, sqlite3.err = sqlite3.runtime.CompileModule(ctx, bin)
-}
-
-type module struct {
-	ctx context.Context
-	mod api.Module
-	vfs io.Closer
-	api sqliteAPI
-	arg [8]uint64
-}
-
-func newModule(mod api.Module) (m *module, err error) {
-	m = new(module)
-	m.mod = mod
-	m.ctx, m.vfs = vfs.NewContext(context.Background())
-
-	getFun := func(name string) api.Function {
-		f := mod.ExportedFunction(name)
-		if f == nil {
-			err = util.NoFuncErr + util.ErrorString(name)
-			return nil
-		}
-		return f
-	}
-
-	getVal := func(name string) uint32 {
-		g := mod.ExportedGlobal(name)
-		if g == nil {
-			err = util.NoGlobalErr + util.ErrorString(name)
-			return 0
-		}
-		return util.ReadUint32(mod, uint32(g.Get()))
-	}
-
-	m.api = sqliteAPI{
-		free:            getFun("free"),
-		malloc:          getFun("malloc"),
-		destructor:      getVal("malloc_destructor"),
-		errcode:         getFun("sqlite3_errcode"),
-		errstr:          getFun("sqlite3_errstr"),
-		errmsg:          getFun("sqlite3_errmsg"),
-		erroff:          getFun("sqlite3_error_offset"),
-		open:            getFun("sqlite3_open_v2"),
-		close:           getFun("sqlite3_close"),
-		closeZombie:     getFun("sqlite3_close_v2"),
-		prepare:         getFun("sqlite3_prepare_v3"),
-		finalize:        getFun("sqlite3_finalize"),
-		reset:           getFun("sqlite3_reset"),
-		step:            getFun("sqlite3_step"),
-		exec:            getFun("sqlite3_exec"),
-		clearBindings:   getFun("sqlite3_clear_bindings"),
-		bindCount:       getFun("sqlite3_bind_parameter_count"),
-		bindIndex:       getFun("sqlite3_bind_parameter_index"),
-		bindName:        getFun("sqlite3_bind_parameter_name"),
-		bindNull:        getFun("sqlite3_bind_null"),
-		bindInteger:     getFun("sqlite3_bind_int64"),
-		bindFloat:       getFun("sqlite3_bind_double"),
-		bindText:        getFun("sqlite3_bind_text64"),
-		bindBlob:        getFun("sqlite3_bind_blob64"),
-		bindZeroBlob:    getFun("sqlite3_bind_zeroblob64"),
-		columnCount:     getFun("sqlite3_column_count"),
-		columnName:      getFun("sqlite3_column_name"),
-		columnType:      getFun("sqlite3_column_type"),
-		columnInteger:   getFun("sqlite3_column_int64"),
-		columnFloat:     getFun("sqlite3_column_double"),
-		columnText:      getFun("sqlite3_column_text"),
-		columnBlob:      getFun("sqlite3_column_blob"),
-		columnBytes:     getFun("sqlite3_column_bytes"),
-		blobOpen:        getFun("sqlite3_blob_open"),
-		blobClose:       getFun("sqlite3_blob_close"),
-		blobReopen:      getFun("sqlite3_blob_reopen"),
-		blobBytes:       getFun("sqlite3_blob_bytes"),
-		blobRead:        getFun("sqlite3_blob_read"),
-		blobWrite:       getFun("sqlite3_blob_write"),
-		backupInit:      getFun("sqlite3_backup_init"),
-		backupStep:      getFun("sqlite3_backup_step"),
-		backupFinish:    getFun("sqlite3_backup_finish"),
-		backupRemaining: getFun("sqlite3_backup_remaining"),
-		backupPageCount: getFun("sqlite3_backup_pagecount"),
-		changes:         getFun("sqlite3_changes64"),
-		lastRowid:       getFun("sqlite3_last_insert_rowid"),
-		autocommit:      getFun("sqlite3_get_autocommit"),
-	}
-	if err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func (m *module) close() error {
-	err := m.mod.Close(m.ctx)
-	m.vfs.Close()
-	return err
-}
-
-func (m *module) error(rc uint64, handle uint32, sql ...string) error {
-	if rc == _OK {
-		return nil
-	}
-
-	err := Error{code: rc}
-
-	if err.Code() == NOMEM || err.ExtendedCode() == IOERR_NOMEM {
-		panic(util.OOMErr)
-	}
-
-	if r := m.call(m.api.errstr, rc); r != 0 {
-		err.str = util.ReadString(m.mod, uint32(r), _MAX_STRING)
-	}
-
-	if r := m.call(m.api.errmsg, uint64(handle)); r != 0 {
-		err.msg = util.ReadString(m.mod, uint32(r), _MAX_STRING)
-	}
-
-	if sql != nil {
-		if r := m.call(m.api.erroff, uint64(handle)); r != math.MaxUint32 {
-			err.sql = sql[0][r:]
-		}
-	}
-
-	switch err.msg {
-	case err.str, "not an error":
-		err.msg = ""
-	}
-	return &err
-}
-
-func (m *module) call(fn api.Function, params ...uint64) uint64 {
-	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 m.arg[0]
-}
-
-func (m *module) free(ptr uint32) {
-	if ptr == 0 {
-		return
-	}
-	m.call(m.api.free, uint64(ptr))
-}
-
-func (m *module) new(size uint64) uint32 {
-	if size > _MAX_ALLOCATION_SIZE {
-		panic(util.OOMErr)
-	}
-	ptr := uint32(m.call(m.api.malloc, size))
-	if ptr == 0 && size != 0 {
-		panic(util.OOMErr)
-	}
-	return ptr
-}
-
-func (m *module) newBytes(b []byte) uint32 {
-	if b == nil {
-		return 0
-	}
-	ptr := m.new(uint64(len(b)))
-	util.WriteBytes(m.mod, ptr, b)
-	return ptr
-}
-
-func (m *module) newString(s string) uint32 {
-	ptr := m.new(uint64(len(s) + 1))
-	util.WriteString(m.mod, ptr, s)
-	return ptr
-}
-
-func (m *module) newArena(size uint64) arena {
-	return arena{
-		m:    m,
-		base: m.new(size),
-		size: uint32(size),
-	}
-}
-
-type arena struct {
-	m    *module
-	ptrs []uint32
-	base uint32
-	next uint32
-	size uint32
-}
-
-func (a *arena) free() {
-	if a.m == nil {
-		return
-	}
-	a.reset()
-	a.m.free(a.base)
-	a.m = nil
-}
-
-func (a *arena) reset() {
-	for _, ptr := range a.ptrs {
-		a.m.free(ptr)
-	}
-	a.ptrs = nil
-	a.next = 0
-}
-
-func (a *arena) new(size uint64) uint32 {
-	if size <= uint64(a.size-a.next) {
-		ptr := a.base + a.next
-		a.next += uint32(size)
-		return ptr
-	}
-	ptr := a.m.new(size)
-	a.ptrs = append(a.ptrs, ptr)
-	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)
-	return ptr
-}
-
-type sqliteAPI struct {
-	free            api.Function
-	malloc          api.Function
-	errcode         api.Function
-	errstr          api.Function
-	errmsg          api.Function
-	erroff          api.Function
-	open            api.Function
-	close           api.Function
-	closeZombie     api.Function
-	prepare         api.Function
-	finalize        api.Function
-	reset           api.Function
-	step            api.Function
-	exec            api.Function
-	clearBindings   api.Function
-	bindNull        api.Function
-	bindCount       api.Function
-	bindIndex       api.Function
-	bindName        api.Function
-	bindInteger     api.Function
-	bindFloat       api.Function
-	bindText        api.Function
-	bindBlob        api.Function
-	bindZeroBlob    api.Function
-	columnCount     api.Function
-	columnName      api.Function
-	columnType      api.Function
-	columnInteger   api.Function
-	columnFloat     api.Function
-	columnText      api.Function
-	columnBlob      api.Function
-	columnBytes     api.Function
-	blobOpen        api.Function
-	blobClose       api.Function
-	blobReopen      api.Function
-	blobBytes       api.Function
-	blobRead        api.Function
-	blobWrite       api.Function
-	backupInit      api.Function
-	backupStep      api.Function
-	backupFinish    api.Function
-	backupRemaining api.Function
-	backupPageCount api.Function
-	changes         api.Function
-	lastRowid       api.Function
-	autocommit      api.Function
-	destructor      uint32
-}

vendor/github.com/ncruces/go-sqlite3/pointer.go

@@ -0,0 +1,12 @@
+package sqlite3
+
+import "github.com/ncruces/go-sqlite3/internal/util"
+
+// Pointer returns a pointer to a value that can be used as an argument to
+// [database/sql.DB.Exec] and similar methods.
+// Pointer should NOT be used with [BindPointer] or [ResultPointer].
+//
+// https://sqlite.org/bindptr.html
+func Pointer[T any](value T) any {
+	return util.Pointer[T]{Value: value}
+}

vendor/github.com/ncruces/go-sqlite3/quote.go

@@ -0,0 +1,112 @@
+package sqlite3
+
+import (
+	"bytes"
+	"math"
+	"strconv"
+	"strings"
+	"time"
+	"unsafe"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+)
+
+// Quote escapes and quotes a value
+// making it safe to embed in SQL text.
+func Quote(value any) string {
+	switch v := value.(type) {
+	case nil:
+		return "NULL"
+	case bool:
+		if v {
+			return "1"
+		} else {
+			return "0"
+		}
+
+	case int:
+		return strconv.Itoa(v)
+	case int64:
+		return strconv.FormatInt(v, 10)
+	case float64:
+		switch {
+		case math.IsNaN(v):
+			return "NULL"
+		case math.IsInf(v, 1):
+			return "9.0e999"
+		case math.IsInf(v, -1):
+			return "-9.0e999"
+		}
+		return strconv.FormatFloat(v, 'g', -1, 64)
+	case time.Time:
+		return "'" + v.Format(time.RFC3339Nano) + "'"
+
+	case string:
+		if strings.IndexByte(v, 0) >= 0 {
+			break
+		}
+
+		buf := make([]byte, 2+len(v)+strings.Count(v, "'"))
+		buf[0] = '\''
+		i := 1
+		for _, b := range []byte(v) {
+			if b == '\'' {
+				buf[i] = b
+				i += 1
+			}
+			buf[i] = b
+			i += 1
+		}
+		buf[i] = '\''
+		return unsafe.String(&buf[0], len(buf))
+
+	case []byte:
+		buf := make([]byte, 3+2*len(v))
+		buf[0] = 'x'
+		buf[1] = '\''
+		i := 2
+		for _, b := range v {
+			const hex = "0123456789ABCDEF"
+			buf[i+0] = hex[b/16]
+			buf[i+1] = hex[b%16]
+			i += 2
+		}
+		buf[i] = '\''
+		return unsafe.String(&buf[0], len(buf))
+
+	case ZeroBlob:
+		if v > ZeroBlob(1e9-3)/2 {
+			break
+		}
+
+		buf := bytes.Repeat([]byte("0"), int(3+2*int64(v)))
+		buf[0] = 'x'
+		buf[1] = '\''
+		buf[len(buf)-1] = '\''
+		return unsafe.String(&buf[0], len(buf))
+	}
+
+	panic(util.ValueErr)
+}
+
+// QuoteIdentifier escapes and quotes an identifier
+// making it safe to embed in SQL text.
+func QuoteIdentifier(id string) string {
+	if strings.IndexByte(id, 0) >= 0 {
+		panic(util.ValueErr)
+	}
+
+	buf := make([]byte, 2+len(id)+strings.Count(id, `"`))
+	buf[0] = '"'
+	i := 1
+	for _, b := range []byte(id) {
+		if b == '"' {
+			buf[i] = b
+			i += 1
+		}
+		buf[i] = b
+		i += 1
+	}
+	buf[i] = '"'
+	return unsafe.String(&buf[0], len(buf))
+}

vendor/github.com/ncruces/go-sqlite3/sqlite.go

@@ -0,0 +1,333 @@
+// Package sqlite3 wraps the C SQLite API.
+package sqlite3
+
+import (
+	"context"
+	"math"
+	"math/bits"
+	"os"
+	"sync"
+	"unsafe"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/ncruces/go-sqlite3/vfs"
+	"github.com/tetratelabs/wazero"
+	"github.com/tetratelabs/wazero/api"
+)
+
+// Configure SQLite Wasm.
+//
+// Importing package embed initializes [Binary]
+// with an appropriate build of SQLite:
+//
+//	import _ "github.com/ncruces/go-sqlite3/embed"
+var (
+	Binary []byte // Wasm binary to load.
+	Path   string // Path to load the binary from.
+
+	RuntimeConfig wazero.RuntimeConfig
+)
+
+var instance struct {
+	runtime  wazero.Runtime
+	compiled wazero.CompiledModule
+	err      error
+	once     sync.Once
+}
+
+func compileSQLite() {
+	if RuntimeConfig == nil {
+		RuntimeConfig = wazero.NewRuntimeConfig()
+	}
+
+	ctx := context.Background()
+	instance.runtime = wazero.NewRuntimeWithConfig(ctx, RuntimeConfig)
+
+	env := instance.runtime.NewHostModuleBuilder("env")
+	env = vfs.ExportHostFunctions(env)
+	env = exportCallbacks(env)
+	_, instance.err = env.Instantiate(ctx)
+	if instance.err != nil {
+		return
+	}
+
+	bin := Binary
+	if bin == nil && Path != "" {
+		bin, instance.err = os.ReadFile(Path)
+		if instance.err != nil {
+			return
+		}
+	}
+	if bin == nil {
+		instance.err = util.NoBinaryErr
+		return
+	}
+
+	instance.compiled, instance.err = instance.runtime.CompileModule(ctx, bin)
+}
+
+type sqlite struct {
+	ctx   context.Context
+	mod   api.Module
+	funcs struct {
+		fn   [32]api.Function
+		id   [32]*byte
+		mask uint32
+	}
+	stack [8]uint64
+	freer uint32
+}
+
+func instantiateSQLite() (sqlt *sqlite, err error) {
+	instance.once.Do(compileSQLite)
+	if instance.err != nil {
+		return nil, instance.err
+	}
+
+	sqlt = new(sqlite)
+	sqlt.ctx = util.NewContext(context.Background())
+
+	sqlt.mod, err = instance.runtime.InstantiateModule(sqlt.ctx,
+		instance.compiled, wazero.NewModuleConfig().WithName(""))
+	if err != nil {
+		return nil, err
+	}
+
+	global := sqlt.mod.ExportedGlobal("malloc_destructor")
+	if global == nil {
+		return nil, util.BadBinaryErr
+	}
+
+	sqlt.freer = util.ReadUint32(sqlt.mod, uint32(global.Get()))
+	if sqlt.freer == 0 {
+		return nil, util.BadBinaryErr
+	}
+	return sqlt, nil
+}
+
+func (sqlt *sqlite) close() error {
+	return sqlt.mod.Close(sqlt.ctx)
+}
+
+func (sqlt *sqlite) error(rc uint64, handle uint32, sql ...string) error {
+	if rc == _OK {
+		return nil
+	}
+
+	err := Error{code: rc}
+
+	if err.Code() == NOMEM || err.ExtendedCode() == IOERR_NOMEM {
+		panic(util.OOMErr)
+	}
+
+	if r := sqlt.call("sqlite3_errstr", rc); r != 0 {
+		err.str = util.ReadString(sqlt.mod, uint32(r), _MAX_NAME)
+	}
+
+	if handle != 0 {
+		if r := sqlt.call("sqlite3_errmsg", uint64(handle)); r != 0 {
+			err.msg = util.ReadString(sqlt.mod, uint32(r), _MAX_LENGTH)
+		}
+
+		if sql != nil {
+			if r := sqlt.call("sqlite3_error_offset", uint64(handle)); r != math.MaxUint32 {
+				err.sql = sql[0][r:]
+			}
+		}
+	}
+
+	switch err.msg {
+	case err.str, "not an error":
+		err.msg = ""
+	}
+	return &err
+}
+
+func (sqlt *sqlite) getfn(name string) api.Function {
+	c := &sqlt.funcs
+	p := unsafe.StringData(name)
+	for i := range c.id {
+		if c.id[i] == p {
+			c.id[i] = nil
+			c.mask &^= uint32(1) << i
+			return c.fn[i]
+		}
+	}
+	return sqlt.mod.ExportedFunction(name)
+}
+
+func (sqlt *sqlite) putfn(name string, fn api.Function) {
+	c := &sqlt.funcs
+	p := unsafe.StringData(name)
+	i := bits.TrailingZeros32(^c.mask)
+	if i < 32 {
+		c.id[i] = p
+		c.fn[i] = fn
+		c.mask |= uint32(1) << i
+	} else {
+		c.id[0] = p
+		c.fn[0] = fn
+		c.mask = uint32(1)
+	}
+}
+
+func (sqlt *sqlite) call(name string, params ...uint64) uint64 {
+	copy(sqlt.stack[:], params)
+	fn := sqlt.getfn(name)
+	err := fn.CallWithStack(sqlt.ctx, sqlt.stack[:])
+	if err != nil {
+		panic(err)
+	}
+	sqlt.putfn(name, fn)
+	return sqlt.stack[0]
+}
+
+func (sqlt *sqlite) free(ptr uint32) {
+	if ptr == 0 {
+		return
+	}
+	sqlt.call("free", uint64(ptr))
+}
+
+func (sqlt *sqlite) new(size uint64) uint32 {
+	if size > _MAX_ALLOCATION_SIZE {
+		panic(util.OOMErr)
+	}
+	ptr := uint32(sqlt.call("malloc", size))
+	if ptr == 0 && size != 0 {
+		panic(util.OOMErr)
+	}
+	return ptr
+}
+
+func (sqlt *sqlite) newBytes(b []byte) uint32 {
+	if (*[0]byte)(b) == nil {
+		return 0
+	}
+	ptr := sqlt.new(uint64(len(b)))
+	util.WriteBytes(sqlt.mod, ptr, b)
+	return ptr
+}
+
+func (sqlt *sqlite) newString(s string) uint32 {
+	ptr := sqlt.new(uint64(len(s) + 1))
+	util.WriteString(sqlt.mod, ptr, s)
+	return ptr
+}
+
+func (sqlt *sqlite) newArena(size uint64) arena {
+	// Ensure the arena's size is a multiple of 8.
+	size = (size + 7) &^ 7
+	return arena{
+		sqlt: sqlt,
+		size: uint32(size),
+		base: sqlt.new(size),
+	}
+}
+
+type arena struct {
+	sqlt *sqlite
+	ptrs []uint32
+	base uint32
+	next uint32
+	size uint32
+}
+
+func (a *arena) free() {
+	if a.sqlt == nil {
+		return
+	}
+	for _, ptr := range a.ptrs {
+		a.sqlt.free(ptr)
+	}
+	a.sqlt.free(a.base)
+	a.sqlt = nil
+}
+
+func (a *arena) mark() (reset func()) {
+	ptrs := len(a.ptrs)
+	next := a.next
+	return func() {
+		for _, ptr := range a.ptrs[ptrs:] {
+			a.sqlt.free(ptr)
+		}
+		a.ptrs = a.ptrs[:ptrs]
+		a.next = next
+	}
+}
+
+func (a *arena) new(size uint64) uint32 {
+	// Align the next address, to 4 or 8 bytes.
+	if size&7 != 0 {
+		a.next = (a.next + 3) &^ 3
+	} else {
+		a.next = (a.next + 7) &^ 7
+	}
+	if size <= uint64(a.size-a.next) {
+		ptr := a.base + a.next
+		a.next += uint32(size)
+		return ptr
+	}
+	ptr := a.sqlt.new(size)
+	a.ptrs = append(a.ptrs, ptr)
+	return ptr
+}
+
+func (a *arena) bytes(b []byte) uint32 {
+	if (*[0]byte)(b) == nil {
+		return 0
+	}
+	ptr := a.new(uint64(len(b)))
+	util.WriteBytes(a.sqlt.mod, ptr, b)
+	return ptr
+}
+
+func (a *arena) string(s string) uint32 {
+	ptr := a.new(uint64(len(s) + 1))
+	util.WriteString(a.sqlt.mod, ptr, s)
+	return ptr
+}
+
+func exportCallbacks(env wazero.HostModuleBuilder) wazero.HostModuleBuilder {
+	util.ExportFuncIII(env, "go_busy_handler", busyCallback)
+	util.ExportFuncII(env, "go_progress_handler", progressCallback)
+	util.ExportFuncII(env, "go_commit_hook", commitCallback)
+	util.ExportFuncVI(env, "go_rollback_hook", rollbackCallback)
+	util.ExportFuncVIIIIJ(env, "go_update_hook", updateCallback)
+	util.ExportFuncIIIII(env, "go_wal_hook", walCallback)
+	util.ExportFuncIIIIII(env, "go_autovacuum_pages", autoVacuumCallback)
+	util.ExportFuncIIIIIII(env, "go_authorizer", authorizerCallback)
+	util.ExportFuncVIII(env, "go_log", logCallback)
+	util.ExportFuncVI(env, "go_destroy", destroyCallback)
+	util.ExportFuncVIIII(env, "go_func", funcCallback)
+	util.ExportFuncVIIIII(env, "go_step", stepCallback)
+	util.ExportFuncVIII(env, "go_final", finalCallback)
+	util.ExportFuncVII(env, "go_value", valueCallback)
+	util.ExportFuncVIIII(env, "go_inverse", inverseCallback)
+	util.ExportFuncVIIII(env, "go_collation_needed", collationCallback)
+	util.ExportFuncIIIIII(env, "go_compare", compareCallback)
+	util.ExportFuncIIIIII(env, "go_vtab_create", vtabModuleCallback(xCreate))
+	util.ExportFuncIIIIII(env, "go_vtab_connect", vtabModuleCallback(xConnect))
+	util.ExportFuncII(env, "go_vtab_disconnect", vtabDisconnectCallback)
+	util.ExportFuncII(env, "go_vtab_destroy", vtabDestroyCallback)
+	util.ExportFuncIII(env, "go_vtab_best_index", vtabBestIndexCallback)
+	util.ExportFuncIIIII(env, "go_vtab_update", vtabUpdateCallback)
+	util.ExportFuncIII(env, "go_vtab_rename", vtabRenameCallback)
+	util.ExportFuncIIIII(env, "go_vtab_find_function", vtabFindFuncCallback)
+	util.ExportFuncII(env, "go_vtab_begin", vtabBeginCallback)
+	util.ExportFuncII(env, "go_vtab_sync", vtabSyncCallback)
+	util.ExportFuncII(env, "go_vtab_commit", vtabCommitCallback)
+	util.ExportFuncII(env, "go_vtab_rollback", vtabRollbackCallback)
+	util.ExportFuncIII(env, "go_vtab_savepoint", vtabSavepointCallback)
+	util.ExportFuncIII(env, "go_vtab_release", vtabReleaseCallback)
+	util.ExportFuncIII(env, "go_vtab_rollback_to", vtabRollbackToCallback)
+	util.ExportFuncIIIIII(env, "go_vtab_integrity", vtabIntegrityCallback)
+	util.ExportFuncIII(env, "go_cur_open", cursorOpenCallback)
+	util.ExportFuncII(env, "go_cur_close", cursorCloseCallback)
+	util.ExportFuncIIIIII(env, "go_cur_filter", cursorFilterCallback)
+	util.ExportFuncII(env, "go_cur_next", cursorNextCallback)
+	util.ExportFuncII(env, "go_cur_eof", cursorEOFCallback)
+	util.ExportFuncIIII(env, "go_cur_column", cursorColumnCallback)
+	util.ExportFuncIII(env, "go_cur_rowid", cursorRowIDCallback)
+	return env
+}

vendor/github.com/ncruces/go-sqlite3/stmt.go

@@ -1,7 +1,9 @@
 package sqlite3
 
 import (
+	"encoding/json"
 	"math"
+	"strconv"
 	"time"
 
 	"github.com/ncruces/go-sqlite3/internal/util"
@@ -9,7 +11,7 @@ import (
 
 // Stmt is a prepared statement object.
 //
-// https://www.sqlite.org/c3ref/stmt.html
+// https://sqlite.org/c3ref/stmt.html
 type Stmt struct {
 	c      *Conn
 	err    error
@@ -20,33 +22,49 @@ type Stmt struct {
 //
 // It is safe to close a nil, zero or closed Stmt.
 //
-// https://www.sqlite.org/c3ref/finalize.html
+// https://sqlite.org/c3ref/finalize.html
 func (s *Stmt) Close() error {
 	if s == nil || s.handle == 0 {
 		return nil
 	}
 
-	r := s.c.call(s.c.api.finalize, uint64(s.handle))
+	r := s.c.call("sqlite3_finalize", uint64(s.handle))
 
 	s.handle = 0
 	return s.c.error(r)
 }
 
+// Conn returns the database connection to which the prepared statement belongs.
+//
+// https://sqlite.org/c3ref/db_handle.html
+func (s *Stmt) Conn() *Conn {
+	return s.c
+}
+
+// ReadOnly returns true if and only if the statement
+// makes no direct changes to the content of the database file.
+//
+// https://sqlite.org/c3ref/stmt_readonly.html
+func (s *Stmt) ReadOnly() bool {
+	r := s.c.call("sqlite3_stmt_readonly", uint64(s.handle))
+	return r != 0
+}
+
 // Reset resets the prepared statement object.
 //
-// https://www.sqlite.org/c3ref/reset.html
+// https://sqlite.org/c3ref/reset.html
 func (s *Stmt) Reset() error {
-	r := s.c.call(s.c.api.reset, uint64(s.handle))
+	r := s.c.call("sqlite3_reset", uint64(s.handle))
 	s.err = nil
 	return s.c.error(r)
 }
 
-// ClearBindings resets all bindings on the prepared statement.
+// Busy determines if a prepared statement has been reset.
 //
-// https://www.sqlite.org/c3ref/clear_bindings.html
-func (s *Stmt) ClearBindings() error {
-	r := s.c.call(s.c.api.clearBindings, uint64(s.handle))
-	return s.c.error(r)
+// https://sqlite.org/c3ref/stmt_busy.html
+func (s *Stmt) Busy() bool {
+	r := s.c.call("sqlite3_stmt_busy", uint64(s.handle))
+	return r != 0
 }
 
 // Step evaluates the SQL statement.
@@ -57,16 +75,17 @@ func (s *Stmt) ClearBindings() error {
 // If an error has occurred, Step returns false;
 // call [Stmt.Err] or [Stmt.Reset] to get the error.
 //
-// https://www.sqlite.org/c3ref/step.html
+// https://sqlite.org/c3ref/step.html
 func (s *Stmt) Step() bool {
 	s.c.checkInterrupt()
-	r := s.c.call(s.c.api.step, uint64(s.handle))
-	if r == _ROW {
-		return true
-	}
-	if r == _DONE {
+	r := s.c.call("sqlite3_step", uint64(s.handle))
+	switch r {
+	case _ROW:
 		s.err = nil
-	} else {
+		return true
+	case _DONE:
+		s.err = nil
+	default:
 		s.err = s.c.error(r)
 	}
 	return false
@@ -75,7 +94,7 @@ func (s *Stmt) Step() bool {
 // Err gets the last error occurred during [Stmt.Step].
 // Err returns nil after [Stmt.Reset] is called.
 //
-// https://www.sqlite.org/c3ref/step.html
+// https://sqlite.org/c3ref/step.html
 func (s *Stmt) Err() error {
 	return s.err
 }
@@ -88,40 +107,64 @@ func (s *Stmt) Exec() error {
 	return s.Reset()
 }
 
+// Status monitors the performance characteristics of prepared statements.
+//
+// https://sqlite.org/c3ref/stmt_status.html
+func (s *Stmt) Status(op StmtStatus, reset bool) int {
+	if op > STMTSTATUS_FILTER_HIT && op != STMTSTATUS_MEMUSED {
+		return 0
+	}
+	var i uint64
+	if reset {
+		i = 1
+	}
+	r := s.c.call("sqlite3_stmt_status", uint64(s.handle),
+		uint64(op), i)
+	return int(int32(r))
+}
+
+// ClearBindings resets all bindings on the prepared statement.
+//
+// https://sqlite.org/c3ref/clear_bindings.html
+func (s *Stmt) ClearBindings() error {
+	r := s.c.call("sqlite3_clear_bindings", uint64(s.handle))
+	return s.c.error(r)
+}
+
 // BindCount returns the number of SQL parameters in the prepared statement.
 //
-// https://www.sqlite.org/c3ref/bind_parameter_count.html
+// https://sqlite.org/c3ref/bind_parameter_count.html
 func (s *Stmt) BindCount() int {
-	r := s.c.call(s.c.api.bindCount,
+	r := s.c.call("sqlite3_bind_parameter_count",
 		uint64(s.handle))
-	return int(r)
+	return int(int32(r))
 }
 
 // BindIndex returns the index of a parameter in the prepared statement
 // given its name.
 //
-// https://www.sqlite.org/c3ref/bind_parameter_index.html
+// https://sqlite.org/c3ref/bind_parameter_index.html
 func (s *Stmt) BindIndex(name string) int {
-	defer s.c.arena.reset()
+	defer s.c.arena.mark()()
 	namePtr := s.c.arena.string(name)
-	r := s.c.call(s.c.api.bindIndex,
+	r := s.c.call("sqlite3_bind_parameter_index",
 		uint64(s.handle), uint64(namePtr))
-	return int(r)
+	return int(int32(r))
 }
 
 // BindName returns the name of a parameter in the prepared statement.
 // The leftmost SQL parameter has an index of 1.
 //
-// https://www.sqlite.org/c3ref/bind_parameter_name.html
+// https://sqlite.org/c3ref/bind_parameter_name.html
 func (s *Stmt) BindName(param int) string {
-	r := s.c.call(s.c.api.bindName,
+	r := s.c.call("sqlite3_bind_parameter_name",
 		uint64(s.handle), uint64(param))
 
 	ptr := uint32(r)
 	if ptr == 0 {
 		return ""
 	}
-	return util.ReadString(s.c.mod, ptr, _MAX_STRING)
+	return util.ReadString(s.c.mod, ptr, _MAX_NAME)
 }
 
 // BindBool binds a bool to the prepared statement.
@@ -129,18 +172,19 @@ func (s *Stmt) BindName(param int) string {
 // SQLite does not have a separate boolean storage class.
 // Instead, boolean values are stored as integers 0 (false) and 1 (true).
 //
-// https://www.sqlite.org/c3ref/bind_blob.html
+// https://sqlite.org/c3ref/bind_blob.html
 func (s *Stmt) BindBool(param int, value bool) error {
+	var i int64
 	if value {
-		return s.BindInt64(param, 1)
+		i = 1
 	}
-	return s.BindInt64(param, 0)
+	return s.BindInt64(param, i)
 }
 
 // BindInt binds an int to the prepared statement.
 // The leftmost SQL parameter has an index of 1.
 //
-// https://www.sqlite.org/c3ref/bind_blob.html
+// https://sqlite.org/c3ref/bind_blob.html
 func (s *Stmt) BindInt(param int, value int) error {
 	return s.BindInt64(param, int64(value))
 }
@@ -148,9 +192,9 @@ func (s *Stmt) BindInt(param int, value int) error {
 // BindInt64 binds an int64 to the prepared statement.
 // The leftmost SQL parameter has an index of 1.
 //
-// https://www.sqlite.org/c3ref/bind_blob.html
+// https://sqlite.org/c3ref/bind_blob.html
 func (s *Stmt) BindInt64(param int, value int64) error {
-	r := s.c.call(s.c.api.bindInteger,
+	r := s.c.call("sqlite3_bind_int64",
 		uint64(s.handle), uint64(param), uint64(value))
 	return s.c.error(r)
 }
@@ -158,9 +202,9 @@ func (s *Stmt) BindInt64(param int, value int64) error {
 // BindFloat binds a float64 to the prepared statement.
 // The leftmost SQL parameter has an index of 1.
 //
-// https://www.sqlite.org/c3ref/bind_blob.html
+// https://sqlite.org/c3ref/bind_blob.html
 func (s *Stmt) BindFloat(param int, value float64) error {
-	r := s.c.call(s.c.api.bindFloat,
+	r := s.c.call("sqlite3_bind_double",
 		uint64(s.handle), uint64(param), math.Float64bits(value))
 	return s.c.error(r)
 }
@@ -168,13 +212,32 @@ func (s *Stmt) BindFloat(param int, value float64) error {
 // BindText binds a string to the prepared statement.
 // The leftmost SQL parameter has an index of 1.
 //
-// https://www.sqlite.org/c3ref/bind_blob.html
+// https://sqlite.org/c3ref/bind_blob.html
 func (s *Stmt) BindText(param int, value string) error {
+	if len(value) > _MAX_LENGTH {
+		return TOOBIG
+	}
 	ptr := s.c.newString(value)
-	r := s.c.call(s.c.api.bindText,
+	r := s.c.call("sqlite3_bind_text64",
 		uint64(s.handle), uint64(param),
 		uint64(ptr), uint64(len(value)),
-		uint64(s.c.api.destructor), _UTF8)
+		uint64(s.c.freer), _UTF8)
+	return s.c.error(r)
+}
+
+// BindRawText binds a []byte to the prepared statement as text.
+// The leftmost SQL parameter has an index of 1.
+//
+// https://sqlite.org/c3ref/bind_blob.html
+func (s *Stmt) BindRawText(param int, value []byte) error {
+	if len(value) > _MAX_LENGTH {
+		return TOOBIG
+	}
+	ptr := s.c.newBytes(value)
+	r := s.c.call("sqlite3_bind_text64",
+		uint64(s.handle), uint64(param),
+		uint64(ptr), uint64(len(value)),
+		uint64(s.c.freer), _UTF8)
 	return s.c.error(r)
 }
 
@@ -182,22 +245,25 @@ func (s *Stmt) BindText(param int, value string) error {
 // The leftmost SQL parameter has an index of 1.
 // Binding a nil slice is the same as calling [Stmt.BindNull].
 //
-// https://www.sqlite.org/c3ref/bind_blob.html
+// https://sqlite.org/c3ref/bind_blob.html
 func (s *Stmt) BindBlob(param int, value []byte) error {
+	if len(value) > _MAX_LENGTH {
+		return TOOBIG
+	}
 	ptr := s.c.newBytes(value)
-	r := s.c.call(s.c.api.bindBlob,
+	r := s.c.call("sqlite3_bind_blob64",
 		uint64(s.handle), uint64(param),
 		uint64(ptr), uint64(len(value)),
-		uint64(s.c.api.destructor))
+		uint64(s.c.freer))
 	return s.c.error(r)
 }
 
 // BindZeroBlob binds a zero-filled, length n BLOB to the prepared statement.
 // The leftmost SQL parameter has an index of 1.
 //
-// https://www.sqlite.org/c3ref/bind_blob.html
+// https://sqlite.org/c3ref/bind_blob.html
 func (s *Stmt) BindZeroBlob(param int, n int64) error {
-	r := s.c.call(s.c.api.bindZeroBlob,
+	r := s.c.call("sqlite3_bind_zeroblob64",
 		uint64(s.handle), uint64(param), uint64(n))
 	return s.c.error(r)
 }
@@ -205,9 +271,9 @@ func (s *Stmt) BindZeroBlob(param int, n int64) error {
 // BindNull binds a NULL to the prepared statement.
 // The leftmost SQL parameter has an index of 1.
 //
-// https://www.sqlite.org/c3ref/bind_blob.html
+// https://sqlite.org/c3ref/bind_blob.html
 func (s *Stmt) BindNull(param int) error {
-	r := s.c.call(s.c.api.bindNull,
+	r := s.c.call("sqlite3_bind_null",
 		uint64(s.handle), uint64(param))
 	return s.c.error(r)
 }
@@ -215,7 +281,7 @@ func (s *Stmt) BindNull(param int) error {
 // BindTime binds a [time.Time] to the prepared statement.
 // The leftmost SQL parameter has an index of 1.
 //
-// https://www.sqlite.org/c3ref/bind_blob.html
+// https://sqlite.org/c3ref/bind_blob.html
 func (s *Stmt) BindTime(param int, value time.Time, format TimeFormat) error {
 	if format == TimeFormatDefault {
 		return s.bindRFC3339Nano(param, value)
@@ -234,71 +300,119 @@ func (s *Stmt) BindTime(param int, value time.Time, format TimeFormat) error {
 }
 
 func (s *Stmt) bindRFC3339Nano(param int, value time.Time) error {
-	const maxlen = uint64(len(time.RFC3339Nano))
+	const maxlen = uint64(len(time.RFC3339Nano)) + 5
 
 	ptr := s.c.new(maxlen)
 	buf := util.View(s.c.mod, ptr, maxlen)
 	buf = value.AppendFormat(buf[:0], time.RFC3339Nano)
 
-	r := s.c.call(s.c.api.bindText,
+	r := s.c.call("sqlite3_bind_text64",
 		uint64(s.handle), uint64(param),
 		uint64(ptr), uint64(len(buf)),
-		uint64(s.c.api.destructor), _UTF8)
+		uint64(s.c.freer), _UTF8)
+	return s.c.error(r)
+}
+
+// BindPointer binds a NULL to the prepared statement, just like [Stmt.BindNull],
+// but it also associates ptr with that NULL value such that it can be retrieved
+// within an application-defined SQL function using [Value.Pointer].
+// The leftmost SQL parameter has an index of 1.
+//
+// https://sqlite.org/c3ref/bind_blob.html
+func (s *Stmt) BindPointer(param int, ptr any) error {
+	valPtr := util.AddHandle(s.c.ctx, ptr)
+	r := s.c.call("sqlite3_bind_pointer_go",
+		uint64(s.handle), uint64(param), uint64(valPtr))
+	return s.c.error(r)
+}
+
+// BindJSON binds the JSON encoding of value to the prepared statement.
+// The leftmost SQL parameter has an index of 1.
+//
+// https://sqlite.org/c3ref/bind_blob.html
+func (s *Stmt) BindJSON(param int, value any) error {
+	data, err := json.Marshal(value)
+	if err != nil {
+		return err
+	}
+	return s.BindRawText(param, data)
+}
+
+// BindValue binds a copy of value to the prepared statement.
+// The leftmost SQL parameter has an index of 1.
+//
+// https://sqlite.org/c3ref/bind_blob.html
+func (s *Stmt) BindValue(param int, value Value) error {
+	if value.c != s.c {
+		return MISUSE
+	}
+	r := s.c.call("sqlite3_bind_value",
+		uint64(s.handle), uint64(param), uint64(value.handle))
 	return s.c.error(r)
 }
 
 // ColumnCount returns the number of columns in a result set.
 //
-// https://www.sqlite.org/c3ref/column_count.html
+// https://sqlite.org/c3ref/column_count.html
 func (s *Stmt) ColumnCount() int {
-	r := s.c.call(s.c.api.columnCount,
+	r := s.c.call("sqlite3_column_count",
 		uint64(s.handle))
-	return int(r)
+	return int(int32(r))
 }
 
 // ColumnName returns the name of the result column.
 // The leftmost column of the result set has the index 0.
 //
-// https://www.sqlite.org/c3ref/column_name.html
+// https://sqlite.org/c3ref/column_name.html
 func (s *Stmt) ColumnName(col int) string {
-	r := s.c.call(s.c.api.columnName,
+	r := s.c.call("sqlite3_column_name",
 		uint64(s.handle), uint64(col))
 
 	ptr := uint32(r)
 	if ptr == 0 {
 		panic(util.OOMErr)
 	}
-	return util.ReadString(s.c.mod, ptr, _MAX_STRING)
+	return util.ReadString(s.c.mod, ptr, _MAX_NAME)
 }
 
 // ColumnType returns the initial [Datatype] of the result column.
 // The leftmost column of the result set has the index 0.
 //
-// https://www.sqlite.org/c3ref/column_blob.html
+// https://sqlite.org/c3ref/column_blob.html
 func (s *Stmt) ColumnType(col int) Datatype {
-	r := s.c.call(s.c.api.columnType,
+	r := s.c.call("sqlite3_column_type",
 		uint64(s.handle), uint64(col))
 	return Datatype(r)
 }
 
+// ColumnDeclType returns the declared datatype of the result column.
+// The leftmost column of the result set has the index 0.
+//
+// https://sqlite.org/c3ref/column_decltype.html
+func (s *Stmt) ColumnDeclType(col int) string {
+	r := s.c.call("sqlite3_column_decltype",
+		uint64(s.handle), uint64(col))
+	if r == 0 {
+		return ""
+	}
+	return util.ReadString(s.c.mod, uint32(r), _MAX_NAME)
+}
+
 // ColumnBool returns the value of the result column as a bool.
 // The leftmost column of the result set has the index 0.
 // SQLite does not have a separate boolean storage class.
 // Instead, boolean values are retrieved as integers,
 // with 0 converted to false and any other value to true.
 //
-// https://www.sqlite.org/c3ref/column_blob.html
+// https://sqlite.org/c3ref/column_blob.html
 func (s *Stmt) ColumnBool(col int) bool {
-	if i := s.ColumnInt64(col); i != 0 {
-		return true
-	}
-	return false
+	return s.ColumnInt64(col) != 0
 }
 
 // ColumnInt returns the value of the result column as an int.
 // The leftmost column of the result set has the index 0.
 //
-// https://www.sqlite.org/c3ref/column_blob.html
+// https://sqlite.org/c3ref/column_blob.html
 func (s *Stmt) ColumnInt(col int) int {
 	return int(s.ColumnInt64(col))
 }
@@ -306,9 +420,9 @@ func (s *Stmt) ColumnInt(col int) int {
 // ColumnInt64 returns the value of the result column as an int64.
 // The leftmost column of the result set has the index 0.
 //
-// https://www.sqlite.org/c3ref/column_blob.html
+// https://sqlite.org/c3ref/column_blob.html
 func (s *Stmt) ColumnInt64(col int) int64 {
-	r := s.c.call(s.c.api.columnInteger,
+	r := s.c.call("sqlite3_column_int64",
 		uint64(s.handle), uint64(col))
 	return int64(r)
 }
@@ -316,9 +430,9 @@ func (s *Stmt) ColumnInt64(col int) int64 {
 // ColumnFloat returns the value of the result column as a float64.
 // The leftmost column of the result set has the index 0.
 //
-// https://www.sqlite.org/c3ref/column_blob.html
+// https://sqlite.org/c3ref/column_blob.html
 func (s *Stmt) ColumnFloat(col int) float64 {
-	r := s.c.call(s.c.api.columnFloat,
+	r := s.c.call("sqlite3_column_double",
 		uint64(s.handle), uint64(col))
 	return math.Float64frombits(r)
 }
@@ -326,7 +440,7 @@ func (s *Stmt) ColumnFloat(col int) float64 {
 // ColumnTime returns the value of the result column as a [time.Time].
 // The leftmost column of the result set has the index 0.
 //
-// https://www.sqlite.org/c3ref/column_blob.html
+// https://sqlite.org/c3ref/column_blob.html
 func (s *Stmt) ColumnTime(col int, format TimeFormat) time.Time {
 	var v any
 	switch s.ColumnType(col) {
@@ -351,7 +465,7 @@ func (s *Stmt) ColumnTime(col int, format TimeFormat) time.Time {
 // ColumnText returns the value of the result column as a string.
 // The leftmost column of the result set has the index 0.
 //
-// https://www.sqlite.org/c3ref/column_blob.html
+// https://sqlite.org/c3ref/column_blob.html
 func (s *Stmt) ColumnText(col int) string {
 	return string(s.ColumnRawText(col))
 }
@@ -360,7 +474,7 @@ func (s *Stmt) ColumnText(col int) string {
 // the value of the result column as a []byte.
 // The leftmost column of the result set has the index 0.
 //
-// https://www.sqlite.org/c3ref/column_blob.html
+// https://sqlite.org/c3ref/column_blob.html
 func (s *Stmt) ColumnBlob(col int, buf []byte) []byte {
 	return append(buf, s.ColumnRawBlob(col)...)
 }
@@ -370,22 +484,11 @@ func (s *Stmt) ColumnBlob(col int, buf []byte) []byte {
 // subsequent calls to [Stmt] methods.
 // The leftmost column of the result set has the index 0.
 //
-// https://www.sqlite.org/c3ref/column_blob.html
+// https://sqlite.org/c3ref/column_blob.html
 func (s *Stmt) ColumnRawText(col int) []byte {
-	r := s.c.call(s.c.api.columnText,
+	r := s.c.call("sqlite3_column_text",
 		uint64(s.handle), uint64(col))
-
-	ptr := uint32(r)
-	if ptr == 0 {
-		r = s.c.call(s.c.api.errcode, uint64(s.c.handle))
-		s.err = s.c.error(r)
-		return nil
-	}
-
-	r = s.c.call(s.c.api.columnBytes,
-		uint64(s.handle), uint64(col))
-
-	return util.View(s.c.mod, ptr, r)
+	return s.columnRawBytes(col, uint32(r))
 }
 
 // ColumnRawBlob returns the value of the result column as a []byte.
@@ -393,35 +496,104 @@ func (s *Stmt) ColumnRawText(col int) []byte {
 // subsequent calls to [Stmt] methods.
 // The leftmost column of the result set has the index 0.
 //
-// https://www.sqlite.org/c3ref/column_blob.html
+// https://sqlite.org/c3ref/column_blob.html
 func (s *Stmt) ColumnRawBlob(col int) []byte {
-	r := s.c.call(s.c.api.columnBlob,
+	r := s.c.call("sqlite3_column_blob",
 		uint64(s.handle), uint64(col))
+	return s.columnRawBytes(col, uint32(r))
+}
 
-	ptr := uint32(r)
+func (s *Stmt) columnRawBytes(col int, ptr uint32) []byte {
 	if ptr == 0 {
-		r = s.c.call(s.c.api.errcode, uint64(s.c.handle))
+		r := s.c.call("sqlite3_errcode", uint64(s.c.handle))
 		s.err = s.c.error(r)
 		return nil
 	}
 
-	r = s.c.call(s.c.api.columnBytes,
+	r := s.c.call("sqlite3_column_bytes",
 		uint64(s.handle), uint64(col))
-
 	return util.View(s.c.mod, ptr, r)
 }
 
-// Return true if stmt is an empty SQL statement.
-// This is used as an optimization.
-// It's OK to always return false here.
-func emptyStatement(stmt string) bool {
-	for _, b := range []byte(stmt) {
-		switch b {
-		case ' ', '\n', '\r', '\t', '\v', '\f':
-		case ';':
-		default:
-			return false
+// ColumnJSON parses the JSON-encoded value of the result column
+// and stores it in the value pointed to by ptr.
+// The leftmost column of the result set has the index 0.
+//
+// https://sqlite.org/c3ref/column_blob.html
+func (s *Stmt) ColumnJSON(col int, ptr any) error {
+	var data []byte
+	switch s.ColumnType(col) {
+	case NULL:
+		data = append(data, "null"...)
+	case TEXT:
+		data = s.ColumnRawText(col)
+	case BLOB:
+		data = s.ColumnRawBlob(col)
+	case INTEGER:
+		data = strconv.AppendInt(nil, s.ColumnInt64(col), 10)
+	case FLOAT:
+		data = strconv.AppendFloat(nil, s.ColumnFloat(col), 'g', -1, 64)
+	default:
+		panic(util.AssertErr())
+	}
+	return json.Unmarshal(data, ptr)
+}
+
+// ColumnValue returns the unprotected value of the result column.
+// The leftmost column of the result set has the index 0.
+//
+// https://sqlite.org/c3ref/column_blob.html
+func (s *Stmt) ColumnValue(col int) Value {
+	r := s.c.call("sqlite3_column_value",
+		uint64(s.handle), uint64(col))
+	return Value{
+		c:      s.c,
+		unprot: true,
+		handle: uint32(r),
+	}
+}
+
+// Columns populates result columns into the provided slice.
+// The slice must have [Stmt.ColumnCount] length.
+//
+// [INTEGER] columns will be retrieved as int64 values,
+// [FLOAT] as float64, [NULL] as nil,
+// [TEXT] as string, and [BLOB] as []byte.
+// Any []byte are owned by SQLite and may be invalidated by
+// subsequent calls to [Stmt] methods.
+func (s *Stmt) Columns(dest []any) error {
+	defer s.c.arena.mark()()
+	count := uint64(len(dest))
+	typePtr := s.c.arena.new(count)
+	dataPtr := s.c.arena.new(8 * count)
+
+	r := s.c.call("sqlite3_columns_go",
+		uint64(s.handle), count, uint64(typePtr), uint64(dataPtr))
+	if err := s.c.error(r); err != nil {
+		return err
+	}
+
+	types := util.View(s.c.mod, typePtr, count)
+	for i := range dest {
+		switch types[i] {
+		case byte(INTEGER):
+			dest[i] = int64(util.ReadUint64(s.c.mod, dataPtr+8*uint32(i)))
+			continue
+		case byte(FLOAT):
+			dest[i] = util.ReadFloat64(s.c.mod, dataPtr+8*uint32(i))
+			continue
+		case byte(NULL):
+			dest[i] = nil
+			continue
+		}
+		ptr := util.ReadUint32(s.c.mod, dataPtr+8*uint32(i)+0)
+		len := util.ReadUint32(s.c.mod, dataPtr+8*uint32(i)+4)
+		buf := util.View(s.c.mod, ptr, uint64(len))
+		if types[i] == byte(TEXT) {
+			dest[i] = string(buf)
+		} else {
+			dest[i] = buf
 		}
 	}
-	return true
+	return nil
 }

vendor/github.com/ncruces/go-sqlite3/time.go

@@ -15,12 +15,12 @@ import (
 // See the documentation for the [TimeFormatDefault] constant
 // for formats recognized by SQLite.
 //
-// https://www.sqlite.org/lang_datefunc.html
+// https://sqlite.org/lang_datefunc.html
 type TimeFormat string
 
 // TimeFormats recognized by SQLite to encode/decode time values.
 //
-// https://www.sqlite.org/lang_datefunc.html
+// https://sqlite.org/lang_datefunc.html#time_values
 const (
 	TimeFormatDefault TimeFormat = "" // time.RFC3339Nano
 
@@ -83,9 +83,9 @@ const (
 // a float64 for [TimeFormatJulianDay] and [TimeFormatUnixFrac],
 // or an int64 for the other numeric formats.
 //
-// https://www.sqlite.org/lang_datefunc.html
+// https://sqlite.org/lang_datefunc.html
 //
-// [collating sequence]: https://www.sqlite.org/datatype3.html#collating_sequences
+// [collating sequence]: https://sqlite.org/datatype3.html#collating_sequences
 func (f TimeFormat) Encode(t time.Time) any {
 	switch f {
 	// Numeric formats
@@ -136,7 +136,7 @@ func (f TimeFormat) Encode(t time.Time) any {
 // Unix timestamps before 1980 and after 9999 may be misinterpreted as julian day numbers,
 // or have the wrong time unit.
 //
-// https://www.sqlite.org/lang_datefunc.html
+// https://sqlite.org/lang_datefunc.html
 func (f TimeFormat) Decode(v any) (time.Time, error) {
 	switch f {
 	// Numeric formats
@@ -164,9 +164,9 @@ func (f TimeFormat) Decode(v any) (time.Time, error) {
 		case float64:
 			sec, frac := math.Modf(v)
 			nsec := math.Floor(frac * 1e9)
-			return time.Unix(int64(sec), int64(nsec)), nil
+			return time.Unix(int64(sec), int64(nsec)).UTC(), nil
 		case int64:
-			return time.Unix(v, 0), nil
+			return time.Unix(v, 0).UTC(), nil
 		default:
 			return time.Time{}, util.TimeErr
 		}
@@ -181,9 +181,9 @@ func (f TimeFormat) Decode(v any) (time.Time, error) {
 		}
 		switch v := v.(type) {
 		case float64:
-			return time.UnixMilli(int64(math.Floor(v))), nil
+			return time.UnixMilli(int64(math.Floor(v))).UTC(), nil
 		case int64:
-			return time.UnixMilli(int64(v)), nil
+			return time.UnixMilli(int64(v)).UTC(), nil
 		default:
 			return time.Time{}, util.TimeErr
 		}
@@ -198,9 +198,9 @@ func (f TimeFormat) Decode(v any) (time.Time, error) {
 		}
 		switch v := v.(type) {
 		case float64:
-			return time.UnixMicro(int64(math.Floor(v))), nil
+			return time.UnixMicro(int64(math.Floor(v))).UTC(), nil
 		case int64:
-			return time.UnixMicro(int64(v)), nil
+			return time.UnixMicro(int64(v)).UTC(), nil
 		default:
 			return time.Time{}, util.TimeErr
 		}
@@ -215,9 +215,9 @@ func (f TimeFormat) Decode(v any) (time.Time, error) {
 		}
 		switch v := v.(type) {
 		case float64:
-			return time.Unix(0, int64(math.Floor(v))), nil
+			return time.Unix(0, int64(math.Floor(v))).UTC(), nil
 		case int64:
-			return time.Unix(0, int64(v)), nil
+			return time.Unix(0, int64(v)).UTC(), nil
 		default:
 			return time.Time{}, util.TimeErr
 		}
@@ -238,26 +238,16 @@ func (f TimeFormat) Decode(v any) (time.Time, error) {
 			}
 
 			dates := []TimeFormat{
-				TimeFormat6TZ, TimeFormat6, TimeFormat3TZ, TimeFormat3,
-				TimeFormat5TZ, TimeFormat5, TimeFormat2TZ, TimeFormat2,
-				TimeFormat1,
+				TimeFormat9, TimeFormat8,
+				TimeFormat6, TimeFormat5,
+				TimeFormat3, TimeFormat2, TimeFormat1,
 			}
 			for _, f := range dates {
-				t, err := time.Parse(string(f), s)
+				t, err := f.Decode(s)
 				if err == nil {
 					return t, nil
 				}
 			}
-
-			times := []TimeFormat{
-				TimeFormat9TZ, TimeFormat9, TimeFormat8TZ, TimeFormat8,
-			}
-			for _, f := range times {
-				t, err := time.Parse(string(f), s)
-				if err == nil {
-					return t.AddDate(2000, 0, 0), nil
-				}
-			}
 		}
 		switch v := v.(type) {
 		case float64:
@@ -314,7 +304,10 @@ func (f TimeFormat) Decode(v any) (time.Time, error) {
 			return time.Time{}, util.TimeErr
 		}
 		t, err := f.parseRelaxed(s)
-		return t.AddDate(2000, 0, 0), err
+		if err != nil {
+			return time.Time{}, err
+		}
+		return t.AddDate(2000, 0, 0), nil
 
 	default:
 		s, ok := v.(string)
@@ -338,3 +331,24 @@ func (f TimeFormat) parseRelaxed(s string) (time.Time, error) {
 	}
 	return t, nil
 }
+
+// Scanner returns a [database/sql.Scanner] that can be used as an argument to
+// [database/sql.Row.Scan] and similar methods to
+// decode a time value into dest using this format.
+func (f TimeFormat) Scanner(dest *time.Time) interface{ Scan(any) error } {
+	return timeScanner{dest, f}
+}
+
+type timeScanner struct {
+	*time.Time
+	TimeFormat
+}
+
+func (s timeScanner) Scan(src any) error {
+	var ok bool
+	var err error
+	if *s.Time, ok = src.(time.Time); !ok {
+		*s.Time, err = s.Decode(src)
+	}
+	return err
+}

vendor/github.com/ncruces/go-sqlite3/tx.go

@@ -1,202 +0,0 @@
-package sqlite3
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"math/rand"
-	"runtime"
-	"strconv"
-)
-
-// Tx is an in-progress database transaction.
-//
-// https://www.sqlite.org/lang_transaction.html
-type Tx struct {
-	c *Conn
-}
-
-// Begin starts a deferred transaction.
-//
-// https://www.sqlite.org/lang_transaction.html
-func (c *Conn) Begin() Tx {
-	// BEGIN even if interrupted.
-	err := c.txExecInterrupted(`BEGIN DEFERRED`)
-	if err != nil {
-		panic(err)
-	}
-	return Tx{c}
-}
-
-// BeginImmediate starts an immediate transaction.
-//
-// https://www.sqlite.org/lang_transaction.html
-func (c *Conn) BeginImmediate() (Tx, error) {
-	err := c.Exec(`BEGIN IMMEDIATE`)
-	if err != nil {
-		return Tx{}, err
-	}
-	return Tx{c}, nil
-}
-
-// BeginExclusive starts an exclusive transaction.
-//
-// https://www.sqlite.org/lang_transaction.html
-func (c *Conn) BeginExclusive() (Tx, error) {
-	err := c.Exec(`BEGIN EXCLUSIVE`)
-	if err != nil {
-		return Tx{}, err
-	}
-	return Tx{c}, nil
-}
-
-// End calls either [Tx.Commit] or [Tx.Rollback]
-// depending on whether *error points to a nil or non-nil error.
-//
-// This is meant to be deferred:
-//
-//	func doWork(conn *sqlite3.Conn) (err error) {
-//		tx := conn.Begin()
-//		defer tx.End(&err)
-//
-//		// ... do work in the transaction
-//	}
-//
-// https://www.sqlite.org/lang_transaction.html
-func (tx Tx) End(errp *error) {
-	recovered := recover()
-	if recovered != nil {
-		defer panic(recovered)
-	}
-
-	if *errp == nil && recovered == nil {
-		// Success path.
-		if tx.c.GetAutocommit() { // There is nothing to commit.
-			return
-		}
-		*errp = tx.Commit()
-		if *errp == nil {
-			return
-		}
-		// Fall through to the error path.
-	}
-
-	// Error path.
-	if tx.c.GetAutocommit() { // There is nothing to rollback.
-		return
-	}
-	err := tx.Rollback()
-	if err != nil {
-		panic(err)
-	}
-}
-
-// Commit commits the transaction.
-//
-// https://www.sqlite.org/lang_transaction.html
-func (tx Tx) Commit() error {
-	return tx.c.Exec(`COMMIT`)
-}
-
-// Rollback rolls back the transaction,
-// even if the connection has been interrupted.
-//
-// https://www.sqlite.org/lang_transaction.html
-func (tx Tx) Rollback() error {
-	return tx.c.txExecInterrupted(`ROLLBACK`)
-}
-
-// Savepoint is a marker within a transaction
-// that allows for partial rollback.
-//
-// https://www.sqlite.org/lang_savepoint.html
-type Savepoint struct {
-	c    *Conn
-	name string
-}
-
-// Savepoint establishes a new transaction savepoint.
-//
-// https://www.sqlite.org/lang_savepoint.html
-func (c *Conn) Savepoint() Savepoint {
-	name := "sqlite3.Savepoint"
-	var pc [1]uintptr
-	if n := runtime.Callers(2, pc[:]); n > 0 {
-		frames := runtime.CallersFrames(pc[:n])
-		frame, _ := frames.Next()
-		if frame.Function != "" {
-			name = frame.Function
-		}
-	}
-	// Names can be reused; this makes catching bugs more likely.
-	name += "#" + strconv.Itoa(int(rand.Int31()))
-
-	err := c.txExecInterrupted(fmt.Sprintf("SAVEPOINT %q;", name))
-	if err != nil {
-		panic(err)
-	}
-	return Savepoint{c: c, name: name}
-}
-
-// Release releases the savepoint rolling back any changes
-// if *error points to a non-nil error.
-//
-// This is meant to be deferred:
-//
-//	func doWork(conn *sqlite3.Conn) (err error) {
-//		savept := conn.Savepoint()
-//		defer savept.Release(&err)
-//
-//		// ... do work in the transaction
-//	}
-func (s Savepoint) Release(errp *error) {
-	recovered := recover()
-	if recovered != nil {
-		defer panic(recovered)
-	}
-
-	if *errp == nil && recovered == nil {
-		// Success path.
-		if s.c.GetAutocommit() { // There is nothing to commit.
-			return
-		}
-		*errp = s.c.Exec(fmt.Sprintf("RELEASE %q;", s.name))
-		if *errp == nil {
-			return
-		}
-		// Fall through to the error path.
-	}
-
-	// Error path.
-	if s.c.GetAutocommit() { // There is nothing to rollback.
-		return
-	}
-	// ROLLBACK and RELEASE even if interrupted.
-	err := s.c.txExecInterrupted(fmt.Sprintf(`
-		ROLLBACK TO %[1]q;
-		RELEASE %[1]q;
-	`, s.name))
-	if err != nil {
-		panic(err)
-	}
-}
-
-// Rollback rolls the transaction back to the savepoint,
-// even if the connection has been interrupted.
-// Rollback does not release the savepoint.
-//
-// https://www.sqlite.org/lang_transaction.html
-func (s Savepoint) Rollback() error {
-	// ROLLBACK even if interrupted.
-	return s.c.txExecInterrupted(fmt.Sprintf("ROLLBACK TO %q;", s.name))
-}
-
-func (c *Conn) txExecInterrupted(sql string) error {
-	err := c.Exec(sql)
-	if errors.Is(err, INTERRUPT) {
-		old := c.SetInterrupt(context.Background())
-		defer c.SetInterrupt(old)
-		err = c.Exec(sql)
-	}
-	return err
-}

vendor/github.com/ncruces/go-sqlite3/txn.go

@@ -0,0 +1,294 @@
+package sqlite3
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"math/rand"
+	"runtime"
+	"strconv"
+	"strings"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/tetratelabs/wazero/api"
+)
+
+// Txn is an in-progress database transaction.
+//
+// https://sqlite.org/lang_transaction.html
+type Txn struct {
+	c *Conn
+}
+
+// Begin starts a deferred transaction.
+//
+// https://sqlite.org/lang_transaction.html
+func (c *Conn) Begin() Txn {
+	// BEGIN even if interrupted.
+	err := c.txnExecInterrupted(`BEGIN DEFERRED`)
+	if err != nil {
+		panic(err)
+	}
+	return Txn{c}
+}
+
+// BeginImmediate starts an immediate transaction.
+//
+// https://sqlite.org/lang_transaction.html
+func (c *Conn) BeginImmediate() (Txn, error) {
+	err := c.Exec(`BEGIN IMMEDIATE`)
+	if err != nil {
+		return Txn{}, err
+	}
+	return Txn{c}, nil
+}
+
+// BeginExclusive starts an exclusive transaction.
+//
+// https://sqlite.org/lang_transaction.html
+func (c *Conn) BeginExclusive() (Txn, error) {
+	err := c.Exec(`BEGIN EXCLUSIVE`)
+	if err != nil {
+		return Txn{}, err
+	}
+	return Txn{c}, nil
+}
+
+// End calls either [Txn.Commit] or [Txn.Rollback]
+// depending on whether *error points to a nil or non-nil error.
+//
+// This is meant to be deferred:
+//
+//	func doWork(db *sqlite3.Conn) (err error) {
+//		tx := db.Begin()
+//		defer tx.End(&err)
+//
+//		// ... do work in the transaction
+//	}
+//
+// https://sqlite.org/lang_transaction.html
+func (tx Txn) End(errp *error) {
+	recovered := recover()
+	if recovered != nil {
+		defer panic(recovered)
+	}
+
+	if *errp == nil && recovered == nil {
+		// Success path.
+		if tx.c.GetAutocommit() { // There is nothing to commit.
+			return
+		}
+		*errp = tx.Commit()
+		if *errp == nil {
+			return
+		}
+		// Fall through to the error path.
+	}
+
+	// Error path.
+	if tx.c.GetAutocommit() { // There is nothing to rollback.
+		return
+	}
+	err := tx.Rollback()
+	if err != nil {
+		panic(err)
+	}
+}
+
+// Commit commits the transaction.
+//
+// https://sqlite.org/lang_transaction.html
+func (tx Txn) Commit() error {
+	return tx.c.Exec(`COMMIT`)
+}
+
+// Rollback rolls back the transaction,
+// even if the connection has been interrupted.
+//
+// https://sqlite.org/lang_transaction.html
+func (tx Txn) Rollback() error {
+	return tx.c.txnExecInterrupted(`ROLLBACK`)
+}
+
+// Savepoint is a marker within a transaction
+// that allows for partial rollback.
+//
+// https://sqlite.org/lang_savepoint.html
+type Savepoint struct {
+	c    *Conn
+	name string
+}
+
+// Savepoint establishes a new transaction savepoint.
+//
+// https://sqlite.org/lang_savepoint.html
+func (c *Conn) Savepoint() Savepoint {
+	// Names can be reused; this makes catching bugs more likely.
+	name := saveptName() + "_" + strconv.Itoa(int(rand.Int31()))
+
+	err := c.txnExecInterrupted(fmt.Sprintf("SAVEPOINT %q;", name))
+	if err != nil {
+		panic(err)
+	}
+	return Savepoint{c: c, name: name}
+}
+
+func saveptName() (name string) {
+	defer func() {
+		if name == "" {
+			name = "sqlite3.Savepoint"
+		}
+	}()
+
+	var pc [8]uintptr
+	n := runtime.Callers(3, pc[:])
+	if n <= 0 {
+		return ""
+	}
+	frames := runtime.CallersFrames(pc[:n])
+	frame, more := frames.Next()
+	for more && (strings.HasPrefix(frame.Function, "database/sql.") ||
+		strings.HasPrefix(frame.Function, "github.com/ncruces/go-sqlite3/driver.")) {
+		frame, more = frames.Next()
+	}
+	return frame.Function
+}
+
+// Release releases the savepoint rolling back any changes
+// if *error points to a non-nil error.
+//
+// This is meant to be deferred:
+//
+//	func doWork(db *sqlite3.Conn) (err error) {
+//		savept := db.Savepoint()
+//		defer savept.Release(&err)
+//
+//		// ... do work in the transaction
+//	}
+func (s Savepoint) Release(errp *error) {
+	recovered := recover()
+	if recovered != nil {
+		defer panic(recovered)
+	}
+
+	if *errp == nil && recovered == nil {
+		// Success path.
+		if s.c.GetAutocommit() { // There is nothing to commit.
+			return
+		}
+		*errp = s.c.Exec(fmt.Sprintf("RELEASE %q;", s.name))
+		if *errp == nil {
+			return
+		}
+		// Fall through to the error path.
+	}
+
+	// Error path.
+	if s.c.GetAutocommit() { // There is nothing to rollback.
+		return
+	}
+	// ROLLBACK and RELEASE even if interrupted.
+	err := s.c.txnExecInterrupted(fmt.Sprintf(`
+		ROLLBACK TO %[1]q;
+		RELEASE %[1]q;
+	`, s.name))
+	if err != nil {
+		panic(err)
+	}
+}
+
+// Rollback rolls the transaction back to the savepoint,
+// even if the connection has been interrupted.
+// Rollback does not release the savepoint.
+//
+// https://sqlite.org/lang_transaction.html
+func (s Savepoint) Rollback() error {
+	// ROLLBACK even if interrupted.
+	return s.c.txnExecInterrupted(fmt.Sprintf("ROLLBACK TO %q;", s.name))
+}
+
+func (c *Conn) txnExecInterrupted(sql string) error {
+	err := c.Exec(sql)
+	if errors.Is(err, INTERRUPT) {
+		old := c.SetInterrupt(context.Background())
+		defer c.SetInterrupt(old)
+		err = c.Exec(sql)
+	}
+	return err
+}
+
+// TxnState starts a deferred transaction.
+//
+// https://sqlite.org/c3ref/txn_state.html
+func (c *Conn) TxnState(schema string) TxnState {
+	var ptr uint32
+	if schema != "" {
+		defer c.arena.mark()()
+		ptr = c.arena.string(schema)
+	}
+	r := c.call("sqlite3_txn_state", uint64(c.handle), uint64(ptr))
+	return TxnState(r)
+}
+
+// CommitHook registers a callback function to be invoked
+// whenever a transaction is committed.
+// Return true to allow the commit operation to continue normally.
+//
+// https://sqlite.org/c3ref/commit_hook.html
+func (c *Conn) CommitHook(cb func() (ok bool)) {
+	var enable uint64
+	if cb != nil {
+		enable = 1
+	}
+	c.call("sqlite3_commit_hook_go", uint64(c.handle), enable)
+	c.commit = cb
+}
+
+// RollbackHook registers a callback function to be invoked
+// whenever a transaction is rolled back.
+//
+// https://sqlite.org/c3ref/commit_hook.html
+func (c *Conn) RollbackHook(cb func()) {
+	var enable uint64
+	if cb != nil {
+		enable = 1
+	}
+	c.call("sqlite3_rollback_hook_go", uint64(c.handle), enable)
+	c.rollback = cb
+}
+
+// UpdateHook registers a callback function to be invoked
+// whenever a row is updated, inserted or deleted in a rowid table.
+//
+// https://sqlite.org/c3ref/update_hook.html
+func (c *Conn) UpdateHook(cb func(action AuthorizerActionCode, schema, table string, rowid int64)) {
+	var enable uint64
+	if cb != nil {
+		enable = 1
+	}
+	c.call("sqlite3_update_hook_go", uint64(c.handle), enable)
+	c.update = cb
+}
+
+func commitCallback(ctx context.Context, mod api.Module, pDB uint32) (rollback uint32) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.commit != nil {
+		if !c.commit() {
+			rollback = 1
+		}
+	}
+	return rollback
+}
+
+func rollbackCallback(ctx context.Context, mod api.Module, pDB uint32) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.rollback != nil {
+		c.rollback()
+	}
+}
+
+func updateCallback(ctx context.Context, mod api.Module, pDB uint32, action AuthorizerActionCode, zSchema, zTabName uint32, rowid uint64) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.update != nil {
+		schema := util.ReadString(mod, zSchema, _MAX_NAME)
+		table := util.ReadString(mod, zTabName, _MAX_NAME)
+		c.update(action, schema, table, int64(rowid))
+	}
+}

vendor/github.com/ncruces/go-sqlite3/util/osutil/open.go

@@ -0,0 +1,16 @@
+//go:build !windows
+
+package osutil
+
+import (
+	"io/fs"
+	"os"
+)
+
+// OpenFile behaves the same as [os.OpenFile],
+// except on Windows it sets [syscall.FILE_SHARE_DELETE].
+//
+// See: https://go.dev/issue/32088#issuecomment-502850674
+func OpenFile(name string, flag int, perm fs.FileMode) (*os.File, error) {
+	return os.OpenFile(name, flag, perm)
+}

vendor/github.com/ncruces/go-sqlite3/util/osutil/open_windows.go

@@ -0,0 +1,112 @@
+package osutil
+
+import (
+	"io/fs"
+	"os"
+	. "syscall"
+	"unsafe"
+)
+
+// OpenFile behaves the same as [os.OpenFile],
+// except on Windows it sets [syscall.FILE_SHARE_DELETE].
+//
+// See: https://go.dev/issue/32088#issuecomment-502850674
+func OpenFile(name string, flag int, perm fs.FileMode) (*os.File, error) {
+	if name == "" {
+		return nil, &os.PathError{Op: "open", Path: name, Err: ENOENT}
+	}
+	r, e := syscallOpen(name, flag, uint32(perm.Perm()))
+	if e != nil {
+		return nil, &os.PathError{Op: "open", Path: name, Err: e}
+	}
+	return os.NewFile(uintptr(r), name), nil
+}
+
+// syscallOpen is a copy of [syscall.Open]
+// that uses [syscall.FILE_SHARE_DELETE].
+//
+// https://go.dev/src/syscall/syscall_windows.go
+func syscallOpen(path string, mode int, perm uint32) (fd Handle, err error) {
+	if len(path) == 0 {
+		return InvalidHandle, ERROR_FILE_NOT_FOUND
+	}
+	pathp, err := UTF16PtrFromString(path)
+	if err != nil {
+		return InvalidHandle, err
+	}
+	var access uint32
+	switch mode & (O_RDONLY | O_WRONLY | O_RDWR) {
+	case O_RDONLY:
+		access = GENERIC_READ
+	case O_WRONLY:
+		access = GENERIC_WRITE
+	case O_RDWR:
+		access = GENERIC_READ | GENERIC_WRITE
+	}
+	if mode&O_CREAT != 0 {
+		access |= GENERIC_WRITE
+	}
+	if mode&O_APPEND != 0 {
+		access &^= GENERIC_WRITE
+		access |= FILE_APPEND_DATA
+	}
+	sharemode := uint32(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE)
+	var sa *SecurityAttributes
+	if mode&O_CLOEXEC == 0 {
+		sa = makeInheritSa()
+	}
+	var createmode uint32
+	switch {
+	case mode&(O_CREAT|O_EXCL) == (O_CREAT | O_EXCL):
+		createmode = CREATE_NEW
+	case mode&(O_CREAT|O_TRUNC) == (O_CREAT | O_TRUNC):
+		createmode = CREATE_ALWAYS
+	case mode&O_CREAT == O_CREAT:
+		createmode = OPEN_ALWAYS
+	case mode&O_TRUNC == O_TRUNC:
+		createmode = TRUNCATE_EXISTING
+	default:
+		createmode = OPEN_EXISTING
+	}
+	var attrs uint32 = FILE_ATTRIBUTE_NORMAL
+	if perm&S_IWRITE == 0 {
+		attrs = FILE_ATTRIBUTE_READONLY
+		if createmode == CREATE_ALWAYS {
+			const _ERROR_BAD_NETPATH = Errno(53)
+			// We have been asked to create a read-only file.
+			// If the file already exists, the semantics of
+			// the Unix open system call is to preserve the
+			// existing permissions. If we pass CREATE_ALWAYS
+			// and FILE_ATTRIBUTE_READONLY to CreateFile,
+			// and the file already exists, CreateFile will
+			// change the file permissions.
+			// Avoid that to preserve the Unix semantics.
+			h, e := CreateFile(pathp, access, sharemode, sa, TRUNCATE_EXISTING, FILE_ATTRIBUTE_NORMAL, 0)
+			switch e {
+			case ERROR_FILE_NOT_FOUND, _ERROR_BAD_NETPATH, ERROR_PATH_NOT_FOUND:
+				// File does not exist. These are the same
+				// errors as Errno.Is checks for ErrNotExist.
+				// Carry on to create the file.
+			default:
+				// Success or some different error.
+				return h, e
+			}
+		}
+	}
+	if createmode == OPEN_EXISTING && access == GENERIC_READ {
+		// Necessary for opening directory handles.
+		attrs |= FILE_FLAG_BACKUP_SEMANTICS
+	}
+	if mode&O_SYNC != 0 {
+		const _FILE_FLAG_WRITE_THROUGH = 0x80000000
+		attrs |= _FILE_FLAG_WRITE_THROUGH
+	}
+	return CreateFile(pathp, access, sharemode, sa, createmode, attrs, 0)
+}
+
+func makeInheritSa() *SecurityAttributes {
+	var sa SecurityAttributes
+	sa.Length = uint32(unsafe.Sizeof(sa))
+	sa.InheritHandle = 1
+	return &sa
+}

vendor/github.com/ncruces/go-sqlite3/util/osutil/osfs.go

@@ -0,0 +1,33 @@
+package osutil
+
+import (
+	"io/fs"
+	"os"
+)
+
+// FS implements [fs.FS], [fs.StatFS], and [fs.ReadFileFS]
+// using package [os].
+//
+// This filesystem does not respect [fs.ValidPath] rules,
+// and fails [testing/fstest.TestFS]!
+//
+// Still, it can be a useful tool to unify implementations
+// that can access either the [os] filesystem or an [fs.FS].
+// It's OK to use this to open files, but you should avoid
+// opening directories, resolving paths, or walking the file system.
+type FS struct{}
+
+// Open implements [fs.FS].
+func (FS) Open(name string) (fs.File, error) {
+	return OpenFile(name, os.O_RDONLY, 0)
+}
+
+// ReadFileFS implements [fs.StatFS].
+func (FS) Stat(name string) (fs.FileInfo, error) {
+	return os.Stat(name)
+}
+
+// ReadFile implements [fs.ReadFileFS].
+func (FS) ReadFile(name string) ([]byte, error) {
+	return os.ReadFile(name)
+}

vendor/github.com/ncruces/go-sqlite3/util/osutil/osutil.go

@@ -0,0 +1,2 @@
+// Package osutil implements operating system utility functions.
+package osutil

vendor/github.com/ncruces/go-sqlite3/value.go

@@ -0,0 +1,236 @@
+package sqlite3
+
+import (
+	"encoding/json"
+	"math"
+	"strconv"
+	"time"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+)
+
+// Value is any value that can be stored in a database table.
+//
+// https://sqlite.org/c3ref/value.html
+type Value struct {
+	c      *Conn
+	handle uint32
+	unprot bool
+	copied bool
+}
+
+func (v Value) protected() uint64 {
+	if v.unprot {
+		panic(util.ValueErr)
+	}
+	return uint64(v.handle)
+}
+
+// Dup makes a copy of the SQL value and returns a pointer to that copy.
+//
+// https://sqlite.org/c3ref/value_dup.html
+func (v Value) Dup() *Value {
+	r := v.c.call("sqlite3_value_dup", uint64(v.handle))
+	return &Value{
+		c:      v.c,
+		copied: true,
+		handle: uint32(r),
+	}
+}
+
+// Close frees an SQL value previously obtained by [Value.Dup].
+//
+// https://sqlite.org/c3ref/value_dup.html
+func (dup *Value) Close() error {
+	if !dup.copied {
+		panic(util.ValueErr)
+	}
+	dup.c.call("sqlite3_value_free", uint64(dup.handle))
+	dup.handle = 0
+	return nil
+}
+
+// Type returns the initial datatype of the value.
+//
+// https://sqlite.org/c3ref/value_blob.html
+func (v Value) Type() Datatype {
+	r := v.c.call("sqlite3_value_type", v.protected())
+	return Datatype(r)
+}
+
+// Type returns the numeric datatype of the value.
+//
+// https://sqlite.org/c3ref/value_blob.html
+func (v Value) NumericType() Datatype {
+	r := v.c.call("sqlite3_value_numeric_type", v.protected())
+	return Datatype(r)
+}
+
+// Bool returns the value as a bool.
+// SQLite does not have a separate boolean storage class.
+// Instead, boolean values are retrieved as integers,
+// with 0 converted to false and any other value to true.
+//
+// https://sqlite.org/c3ref/value_blob.html
+func (v Value) Bool() bool {
+	return v.Int64() != 0
+}
+
+// Int returns the value as an int.
+//
+// https://sqlite.org/c3ref/value_blob.html
+func (v Value) Int() int {
+	return int(v.Int64())
+}
+
+// Int64 returns the value as an int64.
+//
+// https://sqlite.org/c3ref/value_blob.html
+func (v Value) Int64() int64 {
+	r := v.c.call("sqlite3_value_int64", v.protected())
+	return int64(r)
+}
+
+// Float returns the value as a float64.
+//
+// https://sqlite.org/c3ref/value_blob.html
+func (v Value) Float() float64 {
+	r := v.c.call("sqlite3_value_double", v.protected())
+	return math.Float64frombits(r)
+}
+
+// Time returns the value as a [time.Time].
+//
+// https://sqlite.org/c3ref/value_blob.html
+func (v Value) Time(format TimeFormat) time.Time {
+	var a any
+	switch v.Type() {
+	case INTEGER:
+		a = v.Int64()
+	case FLOAT:
+		a = v.Float()
+	case TEXT, BLOB:
+		a = v.Text()
+	case NULL:
+		return time.Time{}
+	default:
+		panic(util.AssertErr())
+	}
+	t, _ := format.Decode(a)
+	return t
+}
+
+// Text returns the value as a string.
+//
+// https://sqlite.org/c3ref/value_blob.html
+func (v Value) Text() string {
+	return string(v.RawText())
+}
+
+// Blob appends to buf and returns
+// the value as a []byte.
+//
+// https://sqlite.org/c3ref/value_blob.html
+func (v Value) Blob(buf []byte) []byte {
+	return append(buf, v.RawBlob()...)
+}
+
+// RawText returns the value as a []byte.
+// The []byte is owned by SQLite and may be invalidated by
+// subsequent calls to [Value] methods.
+//
+// https://sqlite.org/c3ref/value_blob.html
+func (v Value) RawText() []byte {
+	r := v.c.call("sqlite3_value_text", v.protected())
+	return v.rawBytes(uint32(r))
+}
+
+// RawBlob returns the value as a []byte.
+// The []byte is owned by SQLite and may be invalidated by
+// subsequent calls to [Value] methods.
+//
+// https://sqlite.org/c3ref/value_blob.html
+func (v Value) RawBlob() []byte {
+	r := v.c.call("sqlite3_value_blob", v.protected())
+	return v.rawBytes(uint32(r))
+}
+
+func (v Value) rawBytes(ptr uint32) []byte {
+	if ptr == 0 {
+		return nil
+	}
+
+	r := v.c.call("sqlite3_value_bytes", v.protected())
+	return util.View(v.c.mod, ptr, r)
+}
+
+// Pointer gets the pointer associated with this value,
+// or nil if it has no associated pointer.
+func (v Value) Pointer() any {
+	r := v.c.call("sqlite3_value_pointer_go", v.protected())
+	return util.GetHandle(v.c.ctx, uint32(r))
+}
+
+// JSON parses a JSON-encoded value
+// and stores the result in the value pointed to by ptr.
+func (v Value) JSON(ptr any) error {
+	var data []byte
+	switch v.Type() {
+	case NULL:
+		data = append(data, "null"...)
+	case TEXT:
+		data = v.RawText()
+	case BLOB:
+		data = v.RawBlob()
+	case INTEGER:
+		data = strconv.AppendInt(nil, v.Int64(), 10)
+	case FLOAT:
+		data = strconv.AppendFloat(nil, v.Float(), 'g', -1, 64)
+	default:
+		panic(util.AssertErr())
+	}
+	return json.Unmarshal(data, ptr)
+}
+
+// NoChange returns true if and only if the value is unchanged
+// in a virtual table update operatiom.
+//
+// https://sqlite.org/c3ref/value_blob.html
+func (v Value) NoChange() bool {
+	r := v.c.call("sqlite3_value_nochange", v.protected())
+	return r != 0
+}
+
+// InFirst returns the first element
+// on the right-hand side of an IN constraint.
+//
+// https://sqlite.org/c3ref/vtab_in_first.html
+func (v Value) InFirst() (Value, error) {
+	defer v.c.arena.mark()()
+	valPtr := v.c.arena.new(ptrlen)
+	r := v.c.call("sqlite3_vtab_in_first", uint64(v.handle), uint64(valPtr))
+	if err := v.c.error(r); err != nil {
+		return Value{}, err
+	}
+	return Value{
+		c:      v.c,
+		handle: util.ReadUint32(v.c.mod, valPtr),
+	}, nil
+}
+
+// InNext returns the next element
+// on the right-hand side of an IN constraint.
+//
+// https://sqlite.org/c3ref/vtab_in_first.html
+func (v Value) InNext() (Value, error) {
+	defer v.c.arena.mark()()
+	valPtr := v.c.arena.new(ptrlen)
+	r := v.c.call("sqlite3_vtab_in_next", uint64(v.handle), uint64(valPtr))
+	if err := v.c.error(r); err != nil {
+		return Value{}, err
+	}
+	return Value{
+		c:      v.c,
+		handle: util.ReadUint32(v.c.mod, valPtr),
+	}, nil
+}

vendor/github.com/ncruces/go-sqlite3/vfs/README.md

@@ -1,9 +1,79 @@
 # Go SQLite VFS API
 
-This package implements the SQLite [OS Interface](https://www.sqlite.org/vfs.html) (aka VFS).
+This package implements the SQLite [OS Interface](https://sqlite.org/vfs.html) (aka VFS).
 
-It replaces the default VFS with a pure Go implementation,
-that is tested on Linux, macOS and Windows,
-but which should also work on illumos and the various BSDs.
+It replaces the default SQLite VFS with a **pure Go** implementation.
 
-It also exposes interfaces that should allow you to implement your own custom VFSes.
+It also exposes [interfaces](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs#VFS)
+that should allow you to implement your own custom VFSes.
+
+Since it is a from scratch reimplementation,
+there are naturally some ways it deviates from the original.
+
+The main differences are [file locking](#file-locking) and [WAL mode](write-ahead-logging) support.
+
+### File Locking
+
+POSIX advisory locks, which SQLite uses on Unix, are
+[broken by design](https://github.com/sqlite/sqlite/blob/b74eb0/src/os_unix.c#L1073-L1161).
+
+On Linux and macOS, this module uses
+[OFD locks](https://www.gnu.org/software/libc/manual/html_node/Open-File-Description-Locks.html)
+to synchronize access to database files.
+OFD locks are fully compatible with POSIX advisory locks.
+
+On BSD Unixes, this module uses
+[BSD locks](https://man.freebsd.org/cgi/man.cgi?query=flock&sektion=2).
+On BSD, these locks are fully compatible with POSIX advisory locks.
+However, concurrency is reduced with BSD locks
+(`BEGIN IMMEDIATE` behaves the same as `BEGIN EXCLUSIVE`). 
+
+On Windows, this module uses `LockFileEx` and `UnlockFileEx`,
+like SQLite.
+
+On all other platforms, file locking is not supported, and you must use
+[`nolock=1`](https://sqlite.org/uri.html#urinolock)
+(or [`immutable=1`](https://sqlite.org/uri.html#uriimmutable))
+to open database files.\
+To use the [`database/sql`](https://pkg.go.dev/database/sql) driver
+with `nolock=1` you must disable connection pooling by calling
+[`db.SetMaxOpenConns(1)`](https://pkg.go.dev/database/sql#DB.SetMaxOpenConns).
+
+You can use [`vfs.SupportsFileLocking`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs#SupportsFileLocking)
+to check if your platform supports file locking.
+
+### Write-Ahead Logging
+
+On 64-bit Linux and macOS, this module uses `mmap` to implement
+[shared-memory for the WAL-index](https://sqlite.org/wal.html#implementation_of_shared_memory_for_the_wal_index),
+like SQLite.
+
+To allow `mmap` to work, each connection needs to reserve up to 4GB of address space.\
+To limit the amount of address space each connection needs,
+use [`WithMemoryLimitPages`](../tests/testcfg/testcfg.go).
+
+On Windows and BSD, [WAL](https://sqlite.org/wal.html) support is
+[limited](https://sqlite.org/wal.html#noshm).
+`EXCLUSIVE` locking mode can be set to create, read, and write WAL databases.\
+To use `EXCLUSIVE` locking mode with the
+[`database/sql`](https://pkg.go.dev/database/sql) driver
+you must disable connection pooling by calling
+[`db.SetMaxOpenConns(1)`](https://pkg.go.dev/database/sql#DB.SetMaxOpenConns).
+
+On all other platforms, where file locking is not supported, WAL mode does not work.
+
+You can use [`vfs.SupportsSharedMemory`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs#SupportsSharedMemory)
+to check if your platform supports shared memory.
+
+### Batch-Atomic Write
+
+On 64-bit Linux, this module supports [batch-atomic writes](https://sqlite.org/cgi/src/technote/714)
+with the F2FS filesystem.
+
+### Build tags
+
+The VFS can be customized with a few build tags:
+- `sqlite3_flock` forces the use of BSD locks; it can be used on macOS to test the BSD locking implementation.
+- `sqlite3_nosys` prevents importing [`x/sys`](https://pkg.go.dev/golang.org/x/sys);
+  disables locking _and_ shared memory on all platforms.
+- `sqlite3_noshm` disables shared memory on all platforms.

vendor/github.com/ncruces/go-sqlite3/vfs/api.go

@@ -1,13 +1,18 @@
 // Package vfs wraps the C SQLite VFS API.
 package vfs
 
-import "net/url"
+import (
+	"context"
+	"io"
+
+	"github.com/tetratelabs/wazero/api"
+)
 
 // A VFS defines the interface between the SQLite core and the underlying operating system.
 //
 // Use sqlite3.ErrorCode or sqlite3.ExtendedErrorCode to return specific error codes to SQLite.
 //
-// https://www.sqlite.org/c3ref/vfs.html
+// https://sqlite.org/c3ref/vfs.html
 type VFS interface {
 	Open(name string, flags OpenFlag) (File, OpenFlag, error)
 	Delete(name string, syncDir bool) error
@@ -15,13 +20,13 @@ type VFS interface {
 	FullPathname(name string) (string, error)
 }
 
-// VFSParams extends VFS to with the ability to handle URI parameters
-// through the OpenParams method.
+// VFSFilename extends VFS with the ability to use Filename
+// objects for opening files.
 //
-// https://www.sqlite.org/c3ref/uri_boolean.html
-type VFSParams interface {
+// https://sqlite.org/c3ref/filename.html
+type VFSFilename interface {
 	VFS
-	OpenParams(name string, flags OpenFlag, params url.Values) (File, OpenFlag, error)
+	OpenFilename(name *Filename, flags OpenFlag) (File, OpenFlag, error)
 }
 
 // A File represents an open file in the OS interface layer.
@@ -29,7 +34,7 @@ type VFSParams interface {
 // Use sqlite3.ErrorCode or sqlite3.ExtendedErrorCode to return specific error codes to SQLite.
 // In particular, sqlite3.BUSY is necessary to correctly implement lock methods.
 //
-// https://www.sqlite.org/c3ref/io_methods.html
+// https://sqlite.org/c3ref/io_methods.html
 type File interface {
 	Close() error
 	ReadAt(p []byte, off int64) (n int, err error)
@@ -47,16 +52,25 @@ type File interface {
 // FileLockState extends File to implement the
 // SQLITE_FCNTL_LOCKSTATE file control opcode.
 //
-// https://www.sqlite.org/c3ref/c_fcntl_begin_atomic_write.html
+// https://sqlite.org/c3ref/c_fcntl_begin_atomic_write.html#sqlitefcntllockstate
 type FileLockState interface {
 	File
 	LockState() LockLevel
 }
 
+// FileChunkSize extends File to implement the
+// SQLITE_FCNTL_CHUNK_SIZE file control opcode.
+//
+// https://sqlite.org/c3ref/c_fcntl_begin_atomic_write.html#sqlitefcntlchunksize
+type FileChunkSize interface {
+	File
+	ChunkSize(size int)
+}
+
 // FileSizeHint extends File to implement the
 // SQLITE_FCNTL_SIZE_HINT file control opcode.
 //
-// https://www.sqlite.org/c3ref/c_fcntl_begin_atomic_write.html
+// https://sqlite.org/c3ref/c_fcntl_begin_atomic_write.html#sqlitefcntlsizehint
 type FileSizeHint interface {
 	File
 	SizeHint(size int64) error
@@ -65,26 +79,45 @@ type FileSizeHint interface {
 // FileHasMoved extends File to implement the
 // SQLITE_FCNTL_HAS_MOVED file control opcode.
 //
-// https://www.sqlite.org/c3ref/c_fcntl_begin_atomic_write.html
+// https://sqlite.org/c3ref/c_fcntl_begin_atomic_write.html#sqlitefcntlhasmoved
 type FileHasMoved interface {
 	File
 	HasMoved() (bool, error)
 }
 
+// FileOverwrite extends File to implement the
+// SQLITE_FCNTL_OVERWRITE file control opcode.
+//
+// https://sqlite.org/c3ref/c_fcntl_begin_atomic_write.html#sqlitefcntloverwrite
+type FileOverwrite interface {
+	File
+	Overwrite() error
+}
+
+// FilePersistentWAL extends File to implement the
+// SQLITE_FCNTL_PERSIST_WAL file control opcode.
+//
+// https://sqlite.org/c3ref/c_fcntl_begin_atomic_write.html#sqlitefcntlpersistwal
+type FilePersistentWAL interface {
+	File
+	PersistentWAL() bool
+	SetPersistentWAL(bool)
+}
+
 // FilePowersafeOverwrite extends File to implement the
 // SQLITE_FCNTL_POWERSAFE_OVERWRITE file control opcode.
 //
-// https://www.sqlite.org/c3ref/c_fcntl_begin_atomic_write.html
+// https://sqlite.org/c3ref/c_fcntl_begin_atomic_write.html#sqlitefcntlpowersafeoverwrite
 type FilePowersafeOverwrite interface {
 	File
 	PowersafeOverwrite() bool
 	SetPowersafeOverwrite(bool)
 }
 
-// FilePowersafeOverwrite extends File to implement the
+// FileCommitPhaseTwo extends File to implement the
 // SQLITE_FCNTL_COMMIT_PHASETWO file control opcode.
 //
-// https://www.sqlite.org/c3ref/c_fcntl_begin_atomic_write.html
+// https://sqlite.org/c3ref/c_fcntl_begin_atomic_write.html#sqlitefcntlcommitphasetwo
 type FileCommitPhaseTwo interface {
 	File
 	CommitPhaseTwo() error
@@ -94,10 +127,49 @@ type FileCommitPhaseTwo interface {
 // SQLITE_FCNTL_BEGIN_ATOMIC_WRITE, SQLITE_FCNTL_COMMIT_ATOMIC_WRITE
 // and SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE file control opcodes.
 //
-// https://www.sqlite.org/c3ref/c_fcntl_begin_atomic_write.html
+// https://sqlite.org/c3ref/c_fcntl_begin_atomic_write.html#sqlitefcntlbeginatomicwrite
 type FileBatchAtomicWrite interface {
 	File
 	BeginAtomicWrite() error
 	CommitAtomicWrite() error
 	RollbackAtomicWrite() error
 }
+
+// FilePragma extends File to implement the
+// SQLITE_FCNTL_PRAGMA file control opcode.
+//
+// https://sqlite.org/c3ref/c_fcntl_begin_atomic_write.html#sqlitefcntlpragma
+type FilePragma interface {
+	File
+	Pragma(name, value string) (string, error)
+}
+
+// FileCheckpoint extends File to implement the
+// SQLITE_FCNTL_CKPT_START and SQLITE_FCNTL_CKPT_DONE
+// file control opcodes.
+//
+// https://sqlite.org/c3ref/c_fcntl_begin_atomic_write.html#sqlitefcntlckptstart
+type FileCheckpoint interface {
+	File
+	CheckpointDone() error
+	CheckpointStart() error
+}
+
+// FileSharedMemory extends File to possibly implement
+// shared-memory for the WAL-index.
+// The same shared-memory instance must be returned
+// for the entire life of the file.
+// It's OK for SharedMemory to return nil.
+type FileSharedMemory interface {
+	File
+	SharedMemory() SharedMemory
+}
+
+// SharedMemory is a shared-memory WAL-index implementation.
+// Use [NewSharedMemory] to create a shared-memory.
+type SharedMemory interface {
+	shmMap(context.Context, api.Module, int32, int32, bool) (uint32, error)
+	shmLock(int32, int32, _ShmFlag) error
+	shmUnmap(bool)
+	io.Closer
+}

vendor/github.com/ncruces/go-sqlite3/vfs/const.go

@@ -3,12 +3,15 @@ package vfs
 import "github.com/ncruces/go-sqlite3/internal/util"
 
 const (
-	_MAX_STRING          = 512 // Used for short strings: names, error messages…
-	_MAX_PATHNAME        = 512
+	_MAX_NAME            = 1e6 // Self-imposed limit for most NUL terminated strings.
+	_MAX_SQL_LENGTH      = 1e9
+	_MAX_PATHNAME        = 1024
 	_DEFAULT_SECTOR_SIZE = 4096
+
+	ptrlen = 4
 )
 
-// https://www.sqlite.org/rescode.html
+// https://sqlite.org/rescode.html
 type _ErrorCode uint32
 
 func (e _ErrorCode) Error() string {
@@ -17,6 +20,7 @@ func (e _ErrorCode) Error() string {
 
 const (
 	_OK                      _ErrorCode = util.OK
+	_ERROR                   _ErrorCode = util.ERROR
 	_PERM                    _ErrorCode = util.PERM
 	_BUSY                    _ErrorCode = util.BUSY
 	_READONLY                _ErrorCode = util.READONLY
@@ -37,6 +41,10 @@ const (
 	_IOERR_CHECKRESERVEDLOCK _ErrorCode = util.IOERR_CHECKRESERVEDLOCK
 	_IOERR_LOCK              _ErrorCode = util.IOERR_LOCK
 	_IOERR_CLOSE             _ErrorCode = util.IOERR_CLOSE
+	_IOERR_SHMOPEN           _ErrorCode = util.IOERR_SHMOPEN
+	_IOERR_SHMSIZE           _ErrorCode = util.IOERR_SHMSIZE
+	_IOERR_SHMLOCK           _ErrorCode = util.IOERR_SHMLOCK
+	_IOERR_SHMMAP            _ErrorCode = util.IOERR_SHMMAP
 	_IOERR_SEEK              _ErrorCode = util.IOERR_SEEK
 	_IOERR_DELETE_NOENT      _ErrorCode = util.IOERR_DELETE_NOENT
 	_IOERR_BEGIN_ATOMIC      _ErrorCode = util.IOERR_BEGIN_ATOMIC
@@ -44,12 +52,13 @@ const (
 	_IOERR_ROLLBACK_ATOMIC   _ErrorCode = util.IOERR_ROLLBACK_ATOMIC
 	_CANTOPEN_FULLPATH       _ErrorCode = util.CANTOPEN_FULLPATH
 	_CANTOPEN_ISDIR          _ErrorCode = util.CANTOPEN_ISDIR
+	_READONLY_CANTINIT       _ErrorCode = util.READONLY_CANTINIT
 	_OK_SYMLINK              _ErrorCode = util.OK_SYMLINK
 )
 
 // OpenFlag is a flag for the [VFS] Open method.
 //
-// https://www.sqlite.org/c3ref/c_open_autoproxy.html
+// https://sqlite.org/c3ref/c_open_autoproxy.html
 type OpenFlag uint32
 
 const (
@@ -78,7 +87,7 @@ const (
 
 // AccessFlag is a flag for the [VFS] Access method.
 //
-// https://www.sqlite.org/c3ref/c_access_exists.html
+// https://sqlite.org/c3ref/c_access_exists.html
 type AccessFlag uint32
 
 const (
@@ -89,7 +98,7 @@ const (
 
 // SyncFlag is a flag for the [File] Sync method.
 //
-// https://www.sqlite.org/c3ref/c_sync_dataonly.html
+// https://sqlite.org/c3ref/c_sync_dataonly.html
 type SyncFlag uint32
 
 const (
@@ -100,7 +109,7 @@ const (
 
 // LockLevel is a value used with [File] Lock and Unlock methods.
 //
-// https://www.sqlite.org/c3ref/c_lock_exclusive.html
+// https://sqlite.org/c3ref/c_lock_exclusive.html
 type LockLevel uint32
 
 const (
@@ -146,7 +155,7 @@ const (
 
 // DeviceCharacteristic is a flag retuned by the [File] DeviceCharacteristics method.
 //
-// https://www.sqlite.org/c3ref/c_iocap_atomic.html
+// https://sqlite.org/c3ref/c_iocap_atomic.html
 type DeviceCharacteristic uint32
 
 const (
@@ -167,7 +176,7 @@ const (
 	IOCAP_BATCH_ATOMIC          DeviceCharacteristic = 0x00004000
 )
 
-// https://www.sqlite.org/c3ref/c_fcntl_begin_atomic_write.html
+// https://sqlite.org/c3ref/c_fcntl_begin_atomic_write.html
 type _FcntlOpcode uint32
 
 const (
@@ -213,3 +222,13 @@ const (
 	_FCNTL_CKSM_FILE             _FcntlOpcode = 41
 	_FCNTL_RESET_CACHE           _FcntlOpcode = 42
 )
+
+// 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
+)

vendor/github.com/ncruces/go-sqlite3/vfs/file.go

@@ -4,12 +4,12 @@ import (
 	"errors"
 	"io"
 	"io/fs"
-	"net/url"
 	"os"
 	"path/filepath"
 	"runtime"
 	"syscall"
-	"time"
+
+	"github.com/ncruces/go-sqlite3/util/osutil"
 )
 
 type vfsOS struct{}
@@ -69,10 +69,10 @@ func (vfsOS) Access(name string, flags AccessFlag) (bool, error) {
 }
 
 func (vfsOS) Open(name string, flags OpenFlag) (File, OpenFlag, error) {
-	return vfsOS{}.OpenParams(name, flags, nil)
+	return nil, 0, _CANTOPEN
 }
 
-func (vfsOS) OpenParams(name string, flags OpenFlag, params url.Values) (File, OpenFlag, error) {
+func (vfsOS) OpenFilename(name *Filename, flags OpenFlag) (File, OpenFlag, error) {
 	var oflags int
 	if flags&OPEN_EXCLUSIVE != 0 {
 		oflags |= os.O_EXCL
@@ -89,10 +89,10 @@ func (vfsOS) OpenParams(name string, flags OpenFlag, params url.Values) (File, O
 
 	var err error
 	var f *os.File
-	if name == "" {
+	if name == nil {
 		f, err = os.CreateTemp("", "*.db")
 	} else {
-		f, err = osOpenFile(name, oflags, 0666)
+		f, err = osutil.OpenFile(name.String(), oflags, 0666)
 	}
 	if err != nil {
 		if errors.Is(err, syscall.EISDIR) {
@@ -101,7 +101,7 @@ func (vfsOS) OpenParams(name string, flags OpenFlag, params url.Values) (File, O
 		return nil, flags, err
 	}
 
-	if modeof := params.Get("modeof"); modeof != "" {
+	if modeof := name.URIParameter("modeof"); modeof != "" {
 		if err = osSetMode(f, modeof); err != nil {
 			f.Close()
 			return nil, flags, _IOERR_FSTAT
@@ -118,17 +118,19 @@ func (vfsOS) OpenParams(name string, flags OpenFlag, params url.Values) (File, O
 		syncDir: runtime.GOOS != "windows" &&
 			flags&(OPEN_CREATE) != 0 &&
 			flags&(OPEN_MAIN_JOURNAL|OPEN_SUPER_JOURNAL|OPEN_WAL) != 0,
+		shm: NewSharedMemory(name.String()+"-shm", flags),
 	}
 	return &file, flags, nil
 }
 
 type vfsFile struct {
 	*os.File
-	lockTimeout time.Duration
-	lock        LockLevel
-	psow        bool
-	syncDir     bool
-	readOnly    bool
+	shm      SharedMemory
+	lock     LockLevel
+	readOnly bool
+	keepWAL  bool
+	syncDir  bool
+	psow     bool
 }
 
 var (
@@ -136,9 +138,17 @@ var (
 	_ FileLockState          = &vfsFile{}
 	_ FileHasMoved           = &vfsFile{}
 	_ FileSizeHint           = &vfsFile{}
+	_ FilePersistentWAL      = &vfsFile{}
 	_ FilePowersafeOverwrite = &vfsFile{}
 )
 
+func (f *vfsFile) Close() error {
+	if f.shm != nil {
+		f.shm.Close()
+	}
+	return f.File.Close()
+}
+
 func (f *vfsFile) Sync(flags SyncFlag) error {
 	dataonly := (flags & SYNC_DATAONLY) != 0
 	fullsync := (flags & 0x0f) == SYNC_FULL
@@ -166,15 +176,19 @@ func (f *vfsFile) Size() (int64, error) {
 	return f.Seek(0, io.SeekEnd)
 }
 
-func (*vfsFile) SectorSize() int {
+func (f *vfsFile) SectorSize() int {
 	return _DEFAULT_SECTOR_SIZE
 }
 
 func (f *vfsFile) DeviceCharacteristics() DeviceCharacteristic {
-	if f.psow {
-		return IOCAP_POWERSAFE_OVERWRITE
+	var res DeviceCharacteristic
+	if osBatchAtomic(f.File) {
+		res |= IOCAP_BATCH_ATOMIC
 	}
-	return 0
+	if f.psow {
+		res |= IOCAP_POWERSAFE_OVERWRITE
+	}
+	return res
 }
 
 func (f *vfsFile) SizeHint(size int64) error {
@@ -198,4 +212,6 @@ func (f *vfsFile) HasMoved() (bool, error) {
 
 func (f *vfsFile) LockState() LockLevel            { return f.lock }
 func (f *vfsFile) PowersafeOverwrite() bool        { return f.psow }
+func (f *vfsFile) PersistentWAL() bool             { return f.keepWAL }
 func (f *vfsFile) SetPowersafeOverwrite(psow bool) { f.psow = psow }
+func (f *vfsFile) SetPersistentWAL(keepWAL bool)   { f.keepWAL = keepWAL }

vendor/github.com/ncruces/go-sqlite3/vfs/filename.go

@@ -0,0 +1,174 @@
+package vfs
+
+import (
+	"context"
+	"net/url"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/tetratelabs/wazero/api"
+)
+
+// Filename is used by SQLite to pass filenames
+// to the Open method of a VFS.
+//
+// https://sqlite.org/c3ref/filename.html
+type Filename struct {
+	ctx   context.Context
+	mod   api.Module
+	zPath uint32
+	flags OpenFlag
+	stack [2]uint64
+}
+
+// OpenFilename is an internal API users should not call directly.
+func OpenFilename(ctx context.Context, mod api.Module, id uint32, flags OpenFlag) *Filename {
+	if id == 0 {
+		return nil
+	}
+	return &Filename{
+		ctx:   ctx,
+		mod:   mod,
+		zPath: id,
+		flags: flags,
+	}
+}
+
+// String returns this filename as a string.
+func (n *Filename) String() string {
+	if n == nil || n.zPath == 0 {
+		return ""
+	}
+	return util.ReadString(n.mod, 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 {
+	return n.path("sqlite3_filename_database")
+}
+
+// Journal returns the name of the corresponding rollback journal file.
+//
+// https://sqlite.org/c3ref/filename_database.html
+func (n *Filename) Journal() string {
+	return n.path("sqlite3_filename_journal")
+}
+
+// Journal returns the name of the corresponding WAL file.
+//
+// https://sqlite.org/c3ref/filename_database.html
+func (n *Filename) WAL() string {
+	return n.path("sqlite3_filename_wal")
+}
+
+func (n *Filename) path(method string) string {
+	if n == nil || n.zPath == 0 {
+		return ""
+	}
+	n.stack[0] = uint64(n.zPath)
+	fn := n.mod.ExportedFunction(method)
+	if err := fn.CallWithStack(n.ctx, n.stack[:]); err != nil {
+		panic(err)
+	}
+	return util.ReadString(n.mod, uint32(n.stack[0]), _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
+	}
+
+	n.stack[0] = uint64(n.zPath)
+	fn := n.mod.ExportedFunction("sqlite3_database_file_object")
+	if err := fn.CallWithStack(n.ctx, n.stack[:]); err != nil {
+		panic(err)
+	}
+	file, _ := vfsFileGet(n.ctx, n.mod, uint32(n.stack[0])).(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 ""
+	}
+
+	uriKey := n.mod.ExportedFunction("sqlite3_uri_key")
+	n.stack[0] = uint64(n.zPath)
+	n.stack[1] = uint64(0)
+	if err := uriKey.CallWithStack(n.ctx, n.stack[:]); err != nil {
+		panic(err)
+	}
+
+	ptr := uint32(n.stack[0])
+	if ptr == 0 {
+		return ""
+	}
+
+	// Parse the format from:
+	// https://github.com/sqlite/sqlite/blob/b74eb0/src/pager.c#L4797-L4840
+	// This avoids having to alloc/free the key just to find a value.
+	for {
+		k := util.ReadString(n.mod, ptr, _MAX_NAME)
+		if k == "" {
+			return ""
+		}
+		ptr += uint32(len(k)) + 1
+
+		v := util.ReadString(n.mod, ptr, _MAX_NAME)
+		if k == key {
+			return v
+		}
+		ptr += uint32(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
+	}
+
+	uriKey := n.mod.ExportedFunction("sqlite3_uri_key")
+	n.stack[0] = uint64(n.zPath)
+	n.stack[1] = uint64(0)
+	if err := uriKey.CallWithStack(n.ctx, n.stack[:]); err != nil {
+		panic(err)
+	}
+
+	ptr := uint32(n.stack[0])
+	if ptr == 0 {
+		return nil
+	}
+
+	var params url.Values
+
+	// Parse the format from:
+	// https://github.com/sqlite/sqlite/blob/b74eb0/src/pager.c#L4797-L4840
+	// This is the only way to support multiple valued keys.
+	for {
+		k := util.ReadString(n.mod, ptr, _MAX_NAME)
+		if k == "" {
+			return params
+		}
+		ptr += uint32(len(k)) + 1
+
+		v := util.ReadString(n.mod, ptr, _MAX_NAME)
+		if params == nil {
+			params = url.Values{}
+		}
+		params.Add(k, v)
+		ptr += uint32(len(v)) + 1
+	}
+}

vendor/github.com/ncruces/go-sqlite3/vfs/lock.go

@@ -1,11 +1,16 @@
+//go:build (linux || darwin || windows || freebsd || openbsd || netbsd || dragonfly || illumos) && !sqlite3_nosys
+
 package vfs
 
-import (
-	"os"
-	"time"
+import "github.com/ncruces/go-sqlite3/internal/util"
 
-	"github.com/ncruces/go-sqlite3/internal/util"
-)
+// SupportsFileLocking is false on platforms that do not support file locking.
+// To open a database file on those platforms,
+// you need to use the [nolock] or [immutable] URI parameters.
+//
+// [nolock]: https://sqlite.org/uri.html#urinolock
+// [immutable]: https://sqlite.org/uri.html#uriimmutable
+const SupportsFileLocking = true
 
 const (
 	_PENDING_BYTE  = 0x40000000
@@ -48,7 +53,7 @@ func (f *vfsFile) Lock(lock LockLevel) error {
 		if f.lock != LOCK_NONE {
 			panic(util.AssertErr())
 		}
-		if rc := osGetSharedLock(f.File, f.lockTimeout); rc != _OK {
+		if rc := osGetSharedLock(f.File); rc != _OK {
 			return rc
 		}
 		f.lock = LOCK_SHARED
@@ -59,7 +64,7 @@ func (f *vfsFile) Lock(lock LockLevel) error {
 		if f.lock != LOCK_SHARED {
 			panic(util.AssertErr())
 		}
-		if rc := osGetReservedLock(f.File, f.lockTimeout); rc != _OK {
+		if rc := osGetReservedLock(f.File); rc != _OK {
 			return rc
 		}
 		f.lock = LOCK_RESERVED
@@ -70,14 +75,20 @@ func (f *vfsFile) Lock(lock LockLevel) error {
 		if f.lock <= LOCK_NONE || f.lock >= LOCK_EXCLUSIVE {
 			panic(util.AssertErr())
 		}
+		reserved := f.lock == LOCK_RESERVED
 		// A PENDING lock is needed before acquiring an EXCLUSIVE lock.
 		if f.lock < LOCK_PENDING {
-			if rc := osGetPendingLock(f.File); rc != _OK {
+			// If we're already RESERVED, we can block indefinitely,
+			// since only new readers may briefly hold the PENDING lock.
+			if rc := osGetPendingLock(f.File, reserved /* block */); rc != _OK {
 				return rc
 			}
 			f.lock = LOCK_PENDING
 		}
-		if rc := osGetExclusiveLock(f.File, f.lockTimeout); rc != _OK {
+		// We already have PENDING, so we're just waiting for readers to leave.
+		// If we were RESERVED, we can wait for a little while, before invoking
+		// the busy handler; we will only do this once.
+		if rc := osGetExclusiveLock(f.File, reserved /* wait */); rc != _OK {
 			return rc
 		}
 		f.lock = LOCK_EXCLUSIVE
@@ -106,11 +117,9 @@ func (f *vfsFile) Unlock(lock LockLevel) error {
 
 	switch lock {
 	case LOCK_SHARED:
-		if rc := osDowngradeLock(f.File, f.lock); rc != _OK {
-			return rc
-		}
+		rc := osDowngradeLock(f.File, f.lock)
 		f.lock = LOCK_SHARED
-		return nil
+		return rc
 
 	case LOCK_NONE:
 		rc := osReleaseLock(f.File, f.lock)
@@ -133,18 +142,3 @@ func (f *vfsFile) CheckReservedLock() (bool, error) {
 	}
 	return osCheckReservedLock(f.File)
 }
-
-func osGetReservedLock(file *os.File, timeout time.Duration) _ErrorCode {
-	// Acquire the RESERVED lock.
-	return osWriteLock(file, _RESERVED_BYTE, 1, timeout)
-}
-
-func osGetPendingLock(file *os.File) _ErrorCode {
-	// Acquire the PENDING lock.
-	return osWriteLock(file, _PENDING_BYTE, 1, 0)
-}
-
-func osCheckReservedLock(file *os.File) (bool, _ErrorCode) {
-	// Test the RESERVED lock.
-	return osCheckLock(file, _RESERVED_BYTE, 1)
-}

vendor/github.com/ncruces/go-sqlite3/vfs/lock_other.go

@@ -0,0 +1,23 @@
+//go:build !(linux || darwin || windows || freebsd || openbsd || netbsd || dragonfly || illumos) || sqlite3_nosys
+
+package vfs
+
+// SupportsFileLocking is false on platforms that do not support file locking.
+// To open a database file on those platforms,
+// you need to use the [nolock] or [immutable] URI parameters.
+//
+// [nolock]: https://sqlite.org/uri.html#urinolock
+// [immutable]: https://sqlite.org/uri.html#uriimmutable
+const SupportsFileLocking = false
+
+func (f *vfsFile) Lock(LockLevel) error {
+	return _IOERR_LOCK
+}
+
+func (f *vfsFile) Unlock(LockLevel) error {
+	return _IOERR_UNLOCK
+}
+
+func (f *vfsFile) CheckReservedLock() (bool, error) {
+	return false, _IOERR_CHECKRESERVEDLOCK
+}

vendor/github.com/ncruces/go-sqlite3/vfs/os_bsd.go

@@ -1,4 +1,4 @@
-//go:build freebsd || openbsd || netbsd || dragonfly || (darwin && sqlite3_bsd)
+//go:build (freebsd || openbsd || netbsd || dragonfly || illumos || sqlite3_flock) && !sqlite3_nosys
 
 package vfs
 
@@ -19,38 +19,15 @@ func osUnlock(file *os.File, start, len int64) _ErrorCode {
 	return _OK
 }
 
-func osLock(file *os.File, how int, timeout time.Duration, def _ErrorCode) _ErrorCode {
-	var err error
-	for {
-		err = unix.Flock(int(file.Fd()), how)
-		if errno, _ := err.(unix.Errno); errno != unix.EAGAIN {
-			break
-		}
-		if timeout < time.Millisecond {
-			break
-		}
-		timeout -= time.Millisecond
-		time.Sleep(time.Millisecond)
-	}
+func osLock(file *os.File, how int, def _ErrorCode) _ErrorCode {
+	err := unix.Flock(int(file.Fd()), how)
 	return osLockErrorCode(err, def)
 }
 
-func osReadLock(file *os.File, start, len int64, timeout time.Duration) _ErrorCode {
-	return osLock(file, unix.LOCK_SH|unix.LOCK_NB, timeout, _IOERR_RDLOCK)
+func osReadLock(file *os.File, _ /*start*/, _ /*len*/ int64, _ /*timeout*/ time.Duration) _ErrorCode {
+	return osLock(file, unix.LOCK_SH|unix.LOCK_NB, _IOERR_RDLOCK)
 }
 
-func osWriteLock(file *os.File, start, len int64, timeout time.Duration) _ErrorCode {
-	return osLock(file, unix.LOCK_EX|unix.LOCK_NB, timeout, _IOERR_LOCK)
-}
-
-func osCheckLock(file *os.File, start, len int64) (bool, _ErrorCode) {
-	lock := unix.Flock_t{
-		Type:  unix.F_RDLCK,
-		Start: start,
-		Len:   len,
-	}
-	if unix.FcntlFlock(file.Fd(), unix.F_GETLK, &lock) != nil {
-		return false, _IOERR_CHECKRESERVEDLOCK
-	}
-	return lock.Type != unix.F_UNLCK, _OK
+func osWriteLock(file *os.File, _ /*start*/, _ /*len*/ int64, _ /*timeout*/ time.Duration) _ErrorCode {
+	return osLock(file, unix.LOCK_EX|unix.LOCK_NB, _IOERR_LOCK)
 }

vendor/github.com/ncruces/go-sqlite3/vfs/os_darwin.go

@@ -1,4 +1,4 @@
-//go:build !sqlite3_bsd
+//go:build !sqlite3_flock && !sqlite3_nosys
 
 package vfs
 
@@ -14,7 +14,6 @@ const (
 	// https://github.com/apple/darwin-xnu/blob/main/bsd/sys/fcntl.h
 	_F_OFD_SETLK         = 90
 	_F_OFD_SETLKW        = 91
-	_F_OFD_GETLK         = 92
 	_F_OFD_SETLKWTIMEOUT = 93
 )
 
@@ -23,7 +22,7 @@ type flocktimeout_t struct {
 	timeout unix.Timespec
 }
 
-func osSync(file *os.File, fullsync, dataonly bool) error {
+func osSync(file *os.File, fullsync, _ /*dataonly*/ bool) error {
 	if fullsync {
 		return file.Sync()
 	}
@@ -39,12 +38,11 @@ func osAllocate(file *os.File, size int64) error {
 		return nil
 	}
 
-	// https://stackoverflow.com/a/11497568/867786
 	store := unix.Fstore_t{
-		Flags:   unix.F_ALLOCATECONTIG,
+		Flags:   unix.F_ALLOCATEALL | unix.F_ALLOCATECONTIG,
 		Posmode: unix.F_PEOFPOSMODE,
 		Offset:  0,
-		Length:  size,
+		Length:  size - off,
 	}
 
 	// Try to get a continuous chunk of disk space.
@@ -76,9 +74,12 @@ func osLock(file *os.File, typ int16, start, len int64, timeout time.Duration, d
 		Len:   len,
 	}}
 	var err error
-	if timeout == 0 {
+	switch {
+	case timeout == 0:
 		err = unix.FcntlFlock(file.Fd(), _F_OFD_SETLK, &lock.fl)
-	} else {
+	case timeout < 0:
+		err = unix.FcntlFlock(file.Fd(), _F_OFD_SETLKW, &lock.fl)
+	default:
 		lock.timeout = unix.NsecToTimespec(int64(timeout / time.Nanosecond))
 		err = unix.FcntlFlock(file.Fd(), _F_OFD_SETLKWTIMEOUT, &lock.fl)
 	}
@@ -92,15 +93,3 @@ func osReadLock(file *os.File, start, len int64, timeout time.Duration) _ErrorCo
 func osWriteLock(file *os.File, start, len int64, timeout time.Duration) _ErrorCode {
 	return osLock(file, unix.F_WRLCK, start, len, timeout, _IOERR_LOCK)
 }
-
-func osCheckLock(file *os.File, start, len int64) (bool, _ErrorCode) {
-	lock := unix.Flock_t{
-		Type:  unix.F_RDLCK,
-		Start: start,
-		Len:   len,
-	}
-	if unix.FcntlFlock(file.Fd(), _F_OFD_GETLK, &lock) != nil {
-		return false, _IOERR_CHECKRESERVEDLOCK
-	}
-	return lock.Type != unix.F_UNLCK, _OK
-}

vendor/github.com/ncruces/go-sqlite3/vfs/os_f2fs_linux.go

@@ -0,0 +1,34 @@
+//go:build (amd64 || arm64 || riscv64) && !sqlite3_nosys
+
+package vfs
+
+import (
+	"os"
+
+	"golang.org/x/sys/unix"
+)
+
+const (
+	_F2FS_IOC_START_ATOMIC_WRITE  = 62721
+	_F2FS_IOC_COMMIT_ATOMIC_WRITE = 62722
+	_F2FS_IOC_ABORT_ATOMIC_WRITE  = 62725
+	_F2FS_IOC_GET_FEATURES        = 2147808524
+	_F2FS_FEATURE_ATOMIC_WRITE    = 4
+)
+
+func osBatchAtomic(file *os.File) bool {
+	flags, err := unix.IoctlGetInt(int(file.Fd()), _F2FS_IOC_GET_FEATURES)
+	return err == nil && flags&_F2FS_FEATURE_ATOMIC_WRITE != 0
+}
+
+func (f *vfsFile) BeginAtomicWrite() error {
+	return unix.IoctlSetInt(int(f.Fd()), _F2FS_IOC_START_ATOMIC_WRITE, 0)
+}
+
+func (f *vfsFile) CommitAtomicWrite() error {
+	return unix.IoctlSetInt(int(f.Fd()), _F2FS_IOC_COMMIT_ATOMIC_WRITE, 0)
+}
+
+func (f *vfsFile) RollbackAtomicWrite() error {
+	return unix.IoctlSetInt(int(f.Fd()), _F2FS_IOC_ABORT_ATOMIC_WRITE, 0)
+}

vendor/github.com/ncruces/go-sqlite3/vfs/os_linux.go

@@ -1,20 +1,18 @@
+//go:build !sqlite3_nosys
+
 package vfs
 
 import (
+	"math/rand"
 	"os"
+	"time"
 
 	"golang.org/x/sys/unix"
 )
 
-func osSync(file *os.File, fullsync, dataonly bool) error {
-	if dataonly {
-		_, _, err := unix.Syscall(unix.SYS_FDATASYNC, file.Fd(), 0, 0)
-		if err != 0 {
-			return err
-		}
-		return nil
-	}
-	return file.Sync()
+func osSync(file *os.File, _ /*fullsync*/, _ /*dataonly*/ bool) error {
+	// SQLite trusts Linux's fdatasync for all fsync's.
+	return unix.Fdatasync(int(file.Fd()))
 }
 
 func osAllocate(file *os.File, size int64) error {
@@ -23,3 +21,51 @@ func osAllocate(file *os.File, size int64) error {
 	}
 	return unix.Fallocate(int(file.Fd()), 0, 0, size)
 }
+
+func osUnlock(file *os.File, start, len int64) _ErrorCode {
+	err := unix.FcntlFlock(file.Fd(), unix.F_OFD_SETLK, &unix.Flock_t{
+		Type:  unix.F_UNLCK,
+		Start: start,
+		Len:   len,
+	})
+	if err != nil {
+		return _IOERR_UNLOCK
+	}
+	return _OK
+}
+
+func osLock(file *os.File, typ int16, start, len int64, timeout time.Duration, def _ErrorCode) _ErrorCode {
+	lock := unix.Flock_t{
+		Type:  typ,
+		Start: start,
+		Len:   len,
+	}
+	var err error
+	switch {
+	case timeout == 0:
+		err = unix.FcntlFlock(file.Fd(), unix.F_OFD_SETLK, &lock)
+	case timeout < 0:
+		err = unix.FcntlFlock(file.Fd(), unix.F_OFD_SETLKW, &lock)
+	default:
+		before := time.Now()
+		for {
+			err = unix.FcntlFlock(file.Fd(), unix.F_OFD_SETLK, &lock)
+			if errno, _ := err.(unix.Errno); errno != unix.EAGAIN {
+				break
+			}
+			if timeout < time.Since(before) {
+				break
+			}
+			osSleep(time.Duration(rand.Int63n(int64(time.Millisecond))))
+		}
+	}
+	return osLockErrorCode(err, def)
+}
+
+func osReadLock(file *os.File, start, len int64, timeout time.Duration) _ErrorCode {
+	return osLock(file, unix.F_RDLCK, start, len, timeout, _IOERR_RDLOCK)
+}
+
+func osWriteLock(file *os.File, start, len int64, timeout time.Duration) _ErrorCode {
+	return osLock(file, unix.F_WRLCK, start, len, timeout, _IOERR_LOCK)
+}

vendor/github.com/ncruces/go-sqlite3/vfs/os_ofd.go

@@ -1,63 +0,0 @@
-//go:build linux || illumos
-
-package vfs
-
-import (
-	"os"
-	"time"
-
-	"golang.org/x/sys/unix"
-)
-
-func osUnlock(file *os.File, start, len int64) _ErrorCode {
-	err := unix.FcntlFlock(file.Fd(), unix.F_OFD_SETLK, &unix.Flock_t{
-		Type:  unix.F_UNLCK,
-		Start: start,
-		Len:   len,
-	})
-	if err != nil {
-		return _IOERR_UNLOCK
-	}
-	return _OK
-}
-
-func osLock(file *os.File, typ int16, start, len int64, timeout time.Duration, def _ErrorCode) _ErrorCode {
-	lock := unix.Flock_t{
-		Type:  typ,
-		Start: start,
-		Len:   len,
-	}
-	var err error
-	for {
-		err = unix.FcntlFlock(file.Fd(), unix.F_OFD_SETLK, &lock)
-		if errno, _ := err.(unix.Errno); errno != unix.EAGAIN {
-			break
-		}
-		if timeout < time.Millisecond {
-			break
-		}
-		timeout -= time.Millisecond
-		time.Sleep(time.Millisecond)
-	}
-	return osLockErrorCode(err, def)
-}
-
-func osReadLock(file *os.File, start, len int64, timeout time.Duration) _ErrorCode {
-	return osLock(file, unix.F_RDLCK, start, len, timeout, _IOERR_RDLOCK)
-}
-
-func osWriteLock(file *os.File, start, len int64, timeout time.Duration) _ErrorCode {
-	return osLock(file, unix.F_WRLCK, start, len, timeout, _IOERR_LOCK)
-}
-
-func osCheckLock(file *os.File, start, len int64) (bool, _ErrorCode) {
-	lock := unix.Flock_t{
-		Type:  unix.F_RDLCK,
-		Start: start,
-		Len:   len,
-	}
-	if unix.FcntlFlock(file.Fd(), unix.F_OFD_GETLK, &lock) != nil {
-		return false, _IOERR_CHECKRESERVEDLOCK
-	}
-	return lock.Type != unix.F_UNLCK, _OK
-}

vendor/github.com/ncruces/go-sqlite3/vfs/os_std_access.go

@@ -0,0 +1,36 @@
+//go:build !unix || sqlite3_nosys
+
+package vfs
+
+import (
+	"io/fs"
+	"os"
+)
+
+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
+}

vendor/github.com/ncruces/go-sqlite3/vfs/os_std_alloc.go

@@ -1,4 +1,4 @@
-//go:build !linux && (!darwin || sqlite3_bsd)
+//go:build !(linux || darwin) || sqlite3_flock || sqlite3_nosys
 
 package vfs
 
@@ -7,10 +7,6 @@ import (
 	"os"
 )
 
-func osSync(file *os.File, fullsync, dataonly bool) error {
-	return file.Sync()
-}
-
 func osAllocate(file *os.File, size int64) error {
 	off, err := file.Seek(0, io.SeekEnd)
 	if err != nil {

vendor/github.com/ncruces/go-sqlite3/vfs/os_std_atomic.go

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

vendor/github.com/ncruces/go-sqlite3/vfs/os_std_mode.go

@@ -0,0 +1,14 @@
+//go:build !unix || sqlite3_nosys
+
+package vfs
+
+import "os"
+
+func osSetMode(file *os.File, modeof string) error {
+	fi, err := os.Stat(modeof)
+	if err != nil {
+		return err
+	}
+	file.Chmod(fi.Mode())
+	return nil
+}

vendor/github.com/ncruces/go-sqlite3/vfs/os_std_sleep.go

@@ -0,0 +1,9 @@
+//go:build !windows || sqlite3_nosys
+
+package vfs
+
+import "time"
+
+func osSleep(d time.Duration) {
+	time.Sleep(d)
+}

vendor/github.com/ncruces/go-sqlite3/vfs/os_std_sync.go

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

vendor/github.com/ncruces/go-sqlite3/vfs/os_unix.go

@@ -1,20 +1,14 @@
-//go:build unix
+//go:build unix && !sqlite3_nosys
 
 package vfs
 
 import (
-	"io/fs"
 	"os"
 	"syscall"
-	"time"
 
 	"golang.org/x/sys/unix"
 )
 
-func osOpenFile(name string, flag int, perm fs.FileMode) (*os.File, error) {
-	return os.OpenFile(name, flag, perm)
-}
-
 func osAccess(path string, flags AccessFlag) error {
 	var access uint32 // unix.F_OK
 	switch flags {
@@ -37,64 +31,3 @@ func osSetMode(file *os.File, modeof string) error {
 	}
 	return nil
 }
-
-func osGetSharedLock(file *os.File, timeout time.Duration) _ErrorCode {
-	// Test the PENDING lock before acquiring a new SHARED lock.
-	if pending, _ := osCheckLock(file, _PENDING_BYTE, 1); pending {
-		return _BUSY
-	}
-	// Acquire the SHARED lock.
-	return osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, timeout)
-}
-
-func osGetExclusiveLock(file *os.File, timeout time.Duration) _ErrorCode {
-	if timeout == 0 {
-		timeout = time.Millisecond
-	}
-
-	// Acquire the EXCLUSIVE lock.
-	return osWriteLock(file, _SHARED_FIRST, _SHARED_SIZE, timeout)
-}
-
-func osDowngradeLock(file *os.File, state LockLevel) _ErrorCode {
-	if state >= LOCK_EXCLUSIVE {
-		// Downgrade to a SHARED lock.
-		if rc := osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, 0); rc != _OK {
-			// In theory, the downgrade to a SHARED cannot fail because another
-			// process is holding an incompatible lock. If it does, this
-			// indicates that the other process is not following the locking
-			// protocol. If this happens, return _IOERR_RDLOCK. Returning
-			// BUSY would confuse the upper layer.
-			return _IOERR_RDLOCK
-		}
-	}
-	// Release the PENDING and RESERVED locks.
-	return osUnlock(file, _PENDING_BYTE, 2)
-}
-
-func osReleaseLock(file *os.File, _ LockLevel) _ErrorCode {
-	// Release all locks.
-	return osUnlock(file, 0, 0)
-}
-
-func osLockErrorCode(err error, def _ErrorCode) _ErrorCode {
-	if err == nil {
-		return _OK
-	}
-	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 _PERM
-		}
-	}
-	return def
-}

vendor/github.com/ncruces/go-sqlite3/vfs/os_unix_lock.go

@@ -0,0 +1,103 @@
+//go:build (linux || darwin || freebsd || openbsd || netbsd || dragonfly || illumos) && !sqlite3_nosys
+
+package vfs
+
+import (
+	"os"
+	"time"
+
+	"golang.org/x/sys/unix"
+)
+
+func osGetSharedLock(file *os.File) _ErrorCode {
+	// Test the PENDING lock before acquiring a new SHARED lock.
+	if lock, _ := osGetLock(file, _PENDING_BYTE, 1); lock == unix.F_WRLCK {
+		return _BUSY
+	}
+	// Acquire the SHARED lock.
+	return osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, 0)
+}
+
+func osGetReservedLock(file *os.File) _ErrorCode {
+	// Acquire the RESERVED lock.
+	return osWriteLock(file, _RESERVED_BYTE, 1, 0)
+}
+
+func osGetPendingLock(file *os.File, block bool) _ErrorCode {
+	var timeout time.Duration
+	if block {
+		timeout = -1
+	}
+	// Acquire the PENDING lock.
+	return osWriteLock(file, _PENDING_BYTE, 1, timeout)
+}
+
+func osGetExclusiveLock(file *os.File, wait bool) _ErrorCode {
+	var timeout time.Duration
+	if wait {
+		timeout = time.Millisecond
+	}
+	// Acquire the EXCLUSIVE lock.
+	return osWriteLock(file, _SHARED_FIRST, _SHARED_SIZE, timeout)
+}
+
+func osDowngradeLock(file *os.File, state LockLevel) _ErrorCode {
+	if state >= LOCK_EXCLUSIVE {
+		// Downgrade to a SHARED lock.
+		if rc := osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, 0); rc != _OK {
+			// In theory, the downgrade to a SHARED cannot fail because another
+			// process is holding an incompatible lock. If it does, this
+			// indicates that the other process is not following the locking
+			// protocol. If this happens, return _IOERR_RDLOCK. Returning
+			// BUSY would confuse the upper layer.
+			return _IOERR_RDLOCK
+		}
+	}
+	// Release the PENDING and RESERVED locks.
+	return osUnlock(file, _PENDING_BYTE, 2)
+}
+
+func osReleaseLock(file *os.File, _ LockLevel) _ErrorCode {
+	// Release all locks.
+	return osUnlock(file, 0, 0)
+}
+
+func osCheckReservedLock(file *os.File) (bool, _ErrorCode) {
+	// Test the RESERVED lock.
+	lock, rc := osGetLock(file, _RESERVED_BYTE, 1)
+	return lock == unix.F_WRLCK, rc
+}
+
+func osGetLock(file *os.File, start, len int64) (int16, _ErrorCode) {
+	lock := unix.Flock_t{
+		Type:  unix.F_WRLCK,
+		Start: start,
+		Len:   len,
+	}
+	if unix.FcntlFlock(file.Fd(), unix.F_GETLK, &lock) != nil {
+		return 0, _IOERR_CHECKRESERVEDLOCK
+	}
+	return lock.Type, _OK
+}
+
+func osLockErrorCode(err error, def _ErrorCode) _ErrorCode {
+	if err == nil {
+		return _OK
+	}
+	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 _PERM
+		}
+	}
+	return def
+}

vendor/github.com/ncruces/go-sqlite3/vfs/os_windows.go

@@ -1,65 +1,18 @@
+//go:build !sqlite3_nosys
+
 package vfs
 
 import (
-	"io/fs"
+	"math/rand"
 	"os"
-	"syscall"
 	"time"
 
 	"golang.org/x/sys/windows"
 )
 
-// osOpenFile is a simplified copy of [os.openFileNolog]
-// that uses syscall.FILE_SHARE_DELETE.
-// https://go.dev/src/os/file_windows.go
-//
-// See: https://go.dev/issue/32088
-func osOpenFile(name string, flag int, perm fs.FileMode) (*os.File, error) {
-	if name == "" {
-		return nil, &os.PathError{Op: "open", Path: name, Err: syscall.ENOENT}
-	}
-	r, e := syscallOpen(name, flag, uint32(perm.Perm()))
-	if e != nil {
-		return nil, &os.PathError{Op: "open", Path: name, Err: e}
-	}
-	return os.NewFile(uintptr(r), name), nil
-}
-
-func osAccess(path string, flags AccessFlag) error {
-	fi, err := os.Stat(path)
-	if err != nil {
-		return err
-	}
-	if flags == ACCESS_EXISTS {
-		return nil
-	}
-
-	var want fs.FileMode = windows.S_IRUSR
-	if flags == ACCESS_READWRITE {
-		want |= windows.S_IWUSR
-	}
-	if fi.IsDir() {
-		want |= windows.S_IXUSR
-	}
-	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
-}
-
-func osGetSharedLock(file *os.File, timeout time.Duration) _ErrorCode {
+func osGetSharedLock(file *os.File) _ErrorCode {
 	// Acquire the PENDING lock temporarily before acquiring a new SHARED lock.
-	rc := osReadLock(file, _PENDING_BYTE, 1, timeout)
-
+	rc := osReadLock(file, _PENDING_BYTE, 1, 0)
 	if rc == _OK {
 		// Acquire the SHARED lock.
 		rc = osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, 0)
@@ -70,8 +23,24 @@ func osGetSharedLock(file *os.File, timeout time.Duration) _ErrorCode {
 	return rc
 }
 
-func osGetExclusiveLock(file *os.File, timeout time.Duration) _ErrorCode {
-	if timeout == 0 {
+func osGetReservedLock(file *os.File) _ErrorCode {
+	// Acquire the RESERVED lock.
+	return osWriteLock(file, _RESERVED_BYTE, 1, 0)
+}
+
+func osGetPendingLock(file *os.File, block bool) _ErrorCode {
+	var timeout time.Duration
+	if block {
+		timeout = -1
+	}
+
+	// Acquire the PENDING lock.
+	return osWriteLock(file, _PENDING_BYTE, 1, timeout)
+}
+
+func osGetExclusiveLock(file *os.File, wait bool) _ErrorCode {
+	var timeout time.Duration
+	if wait {
 		timeout = time.Millisecond
 	}
 
@@ -90,7 +59,7 @@ func osGetExclusiveLock(file *os.File, timeout time.Duration) _ErrorCode {
 
 func osDowngradeLock(file *os.File, state LockLevel) _ErrorCode {
 	if state >= LOCK_EXCLUSIVE {
-		// Release the SHARED lock.
+		// Release the EXCLUSIVE lock.
 		osUnlock(file, _SHARED_FIRST, _SHARED_SIZE)
 
 		// Reacquire the SHARED lock.
@@ -125,6 +94,19 @@ func osReleaseLock(file *os.File, state LockLevel) _ErrorCode {
 	return _OK
 }
 
+func osCheckReservedLock(file *os.File) (bool, _ErrorCode) {
+	// Test the RESERVED lock.
+	rc := osLock(file, 0, _RESERVED_BYTE, 1, 0, _IOERR_CHECKRESERVEDLOCK)
+	if rc == _BUSY {
+		return true, _OK
+	}
+	if rc == _OK {
+		// Release the RESERVED lock.
+		osUnlock(file, _RESERVED_BYTE, 1)
+	}
+	return false, rc
+}
+
 func osUnlock(file *os.File, start, len uint32) _ErrorCode {
 	err := windows.UnlockFileEx(windows.Handle(file.Fd()),
 		0, len, 0, &windows.Overlapped{Offset: start})
@@ -139,44 +121,38 @@ func osUnlock(file *os.File, start, len uint32) _ErrorCode {
 
 func osLock(file *os.File, flags, start, len uint32, timeout time.Duration, def _ErrorCode) _ErrorCode {
 	var err error
-	for {
-		err = windows.LockFileEx(windows.Handle(file.Fd()), flags,
-			0, len, 0, &windows.Overlapped{Offset: start})
-		if errno, _ := err.(windows.Errno); errno != windows.ERROR_LOCK_VIOLATION {
-			break
+	switch {
+	case timeout == 0:
+		err = osLockEx(file, flags|windows.LOCKFILE_FAIL_IMMEDIATELY, start, len)
+	case timeout < 0:
+		err = osLockEx(file, flags, start, len)
+	default:
+		before := time.Now()
+		for {
+			err = osLockEx(file, flags|windows.LOCKFILE_FAIL_IMMEDIATELY, start, len)
+			if errno, _ := err.(windows.Errno); errno != windows.ERROR_LOCK_VIOLATION {
+				break
+			}
+			if timeout < time.Since(before) {
+				break
+			}
+			osSleep(time.Duration(rand.Int63n(int64(time.Millisecond))))
 		}
-		if timeout < time.Millisecond {
-			break
-		}
-		timeout -= time.Millisecond
-		time.Sleep(time.Millisecond)
 	}
 	return osLockErrorCode(err, def)
 }
 
+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 osReadLock(file *os.File, start, len uint32, timeout time.Duration) _ErrorCode {
-	return osLock(file,
-		windows.LOCKFILE_FAIL_IMMEDIATELY,
-		start, len, timeout, _IOERR_RDLOCK)
+	return osLock(file, 0, start, len, timeout, _IOERR_RDLOCK)
 }
 
 func osWriteLock(file *os.File, start, len uint32, timeout time.Duration) _ErrorCode {
-	return osLock(file,
-		windows.LOCKFILE_FAIL_IMMEDIATELY|windows.LOCKFILE_EXCLUSIVE_LOCK,
-		start, len, timeout, _IOERR_LOCK)
-}
-
-func osCheckLock(file *os.File, start, len uint32) (bool, _ErrorCode) {
-	rc := osLock(file,
-		windows.LOCKFILE_FAIL_IMMEDIATELY,
-		start, len, 0, _IOERR_CHECKRESERVEDLOCK)
-	if rc == _BUSY {
-		return true, _OK
-	}
-	if rc == _OK {
-		osUnlock(file, start, len)
-	}
-	return false, rc
+	return osLock(file, windows.LOCKFILE_EXCLUSIVE_LOCK, start, len, timeout, _IOERR_LOCK)
 }
 
 func osLockErrorCode(err error, def _ErrorCode) _ErrorCode {
@@ -196,54 +172,15 @@ func osLockErrorCode(err error, def _ErrorCode) _ErrorCode {
 	return def
 }
 
-// syscallOpen is a simplified copy of [syscall.Open]
-// that uses syscall.FILE_SHARE_DELETE.
-// https://go.dev/src/syscall/syscall_windows.go
-func syscallOpen(path string, mode int, perm uint32) (fd syscall.Handle, err error) {
-	if len(path) == 0 {
-		return syscall.InvalidHandle, syscall.ERROR_FILE_NOT_FOUND
+func osSleep(d time.Duration) {
+	if d > 0 {
+		period := max(1, d/(5*time.Millisecond))
+		if period < 16 {
+			windows.TimeBeginPeriod(uint32(period))
+		}
+		time.Sleep(d)
+		if period < 16 {
+			windows.TimeEndPeriod(uint32(period))
+		}
 	}
-	pathp, err := syscall.UTF16PtrFromString(path)
-	if err != nil {
-		return syscall.InvalidHandle, err
-	}
-	var access uint32
-	switch mode & (syscall.O_RDONLY | syscall.O_WRONLY | syscall.O_RDWR) {
-	case syscall.O_RDONLY:
-		access = syscall.GENERIC_READ
-	case syscall.O_WRONLY:
-		access = syscall.GENERIC_WRITE
-	case syscall.O_RDWR:
-		access = syscall.GENERIC_READ | syscall.GENERIC_WRITE
-	}
-	if mode&syscall.O_CREAT != 0 {
-		access |= syscall.GENERIC_WRITE
-	}
-	if mode&syscall.O_APPEND != 0 {
-		access &^= syscall.GENERIC_WRITE
-		access |= syscall.FILE_APPEND_DATA
-	}
-	sharemode := uint32(syscall.FILE_SHARE_READ | syscall.FILE_SHARE_WRITE | syscall.FILE_SHARE_DELETE)
-	var createmode uint32
-	switch {
-	case mode&(syscall.O_CREAT|syscall.O_EXCL) == (syscall.O_CREAT | syscall.O_EXCL):
-		createmode = syscall.CREATE_NEW
-	case mode&(syscall.O_CREAT|syscall.O_TRUNC) == (syscall.O_CREAT | syscall.O_TRUNC):
-		createmode = syscall.CREATE_ALWAYS
-	case mode&syscall.O_CREAT == syscall.O_CREAT:
-		createmode = syscall.OPEN_ALWAYS
-	case mode&syscall.O_TRUNC == syscall.O_TRUNC:
-		createmode = syscall.TRUNCATE_EXISTING
-	default:
-		createmode = syscall.OPEN_EXISTING
-	}
-	var attrs uint32 = syscall.FILE_ATTRIBUTE_NORMAL
-	if perm&syscall.S_IWRITE == 0 {
-		attrs = syscall.FILE_ATTRIBUTE_READONLY
-	}
-	if createmode == syscall.OPEN_EXISTING && access == syscall.GENERIC_READ {
-		// Necessary for opening directory handles.
-		attrs |= syscall.FILE_FLAG_BACKUP_SEMANTICS
-	}
-	return syscall.CreateFile(pathp, access, sharemode, nil, createmode, attrs, 0)
 }

vendor/github.com/ncruces/go-sqlite3/vfs/registry.go

@@ -12,7 +12,7 @@ var (
 // If there is no match, nil is returned.
 // If name is empty, the default VFS is returned.
 //
-// https://www.sqlite.org/c3ref/vfs_find.html
+// https://sqlite.org/c3ref/vfs_find.html
 func Find(name string) VFS {
 	if name == "" || name == "os" {
 		return vfsOS{}
@@ -23,8 +23,9 @@ func Find(name string) VFS {
 }
 
 // Register registers a VFS.
+// Empty and "os" are reserved names.
 //
-// https://www.sqlite.org/c3ref/vfs_find.html
+// https://sqlite.org/c3ref/vfs_find.html
 func Register(name string, vfs VFS) {
 	if name == "" || name == "os" {
 		return
@@ -39,7 +40,7 @@ func Register(name string, vfs VFS) {
 
 // Unregister unregisters a VFS.
 //
-// https://www.sqlite.org/c3ref/vfs_find.html
+// https://sqlite.org/c3ref/vfs_find.html
 func Unregister(name string) {
 	vfsRegistryMtx.Lock()
 	defer vfsRegistryMtx.Unlock()

vendor/github.com/ncruces/go-sqlite3/vfs/shm.go

@@ -0,0 +1,173 @@
+//go:build (darwin || linux) && (amd64 || arm64 || riscv64) && !(sqlite3_flock || sqlite3_noshm || sqlite3_nosys)
+
+package vfs
+
+import (
+	"context"
+	"io"
+	"os"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/tetratelabs/wazero/api"
+	"golang.org/x/sys/unix"
+)
+
+// 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
+
+const (
+	_SHM_NLOCK = 8
+	_SHM_BASE  = 120
+	_SHM_DMS   = _SHM_BASE + _SHM_NLOCK
+)
+
+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,
+		readOnly: flags&OPEN_READONLY != 0,
+	}
+}
+
+type vfsShm struct {
+	*os.File
+	path     string
+	regions  []*util.MappedRegion
+	readOnly bool
+}
+
+func (s *vfsShm) shmMap(ctx context.Context, mod api.Module, id, size int32, extend bool) (uint32, error) {
+	// Ensure size is a multiple of the OS page size.
+	if int(size)&(unix.Getpagesize()-1) != 0 {
+		return 0, _IOERR_SHMMAP
+	}
+
+	if s.File == nil {
+		var flag int
+		if s.readOnly {
+			flag = unix.O_RDONLY
+		} else {
+			flag = unix.O_RDWR
+		}
+		f, err := os.OpenFile(s.path,
+			flag|unix.O_CREAT|unix.O_NOFOLLOW, 0666)
+		if err != nil {
+			return 0, _CANTOPEN
+		}
+		s.File = f
+	}
+
+	// Dead man's switch.
+	if lock, rc := osGetLock(s.File, _SHM_DMS, 1); rc != _OK {
+		return 0, _IOERR_LOCK
+	} else if lock == unix.F_WRLCK {
+		return 0, _BUSY
+	} else if lock == unix.F_UNLCK {
+		if s.readOnly {
+			return 0, _READONLY_CANTINIT
+		}
+		if rc := osWriteLock(s.File, _SHM_DMS, 1, 0); rc != _OK {
+			return 0, rc
+		}
+		if err := s.Truncate(0); err != nil {
+			return 0, _IOERR_SHMOPEN
+		}
+	}
+	if rc := osReadLock(s.File, _SHM_DMS, 1, 0); rc != _OK {
+		return 0, rc
+	}
+
+	// Check if file is big enough.
+	o, err := s.Seek(0, io.SeekEnd)
+	if err != nil {
+		return 0, _IOERR_SHMSIZE
+	}
+	if n := (int64(id) + 1) * int64(size); n > o {
+		if !extend {
+			return 0, nil
+		}
+		err := osAllocate(s.File, n)
+		if err != nil {
+			return 0, _IOERR_SHMSIZE
+		}
+	}
+
+	var prot int
+	if s.readOnly {
+		prot = unix.PROT_READ
+	} else {
+		prot = unix.PROT_READ | unix.PROT_WRITE
+	}
+	r, err := util.MapRegion(ctx, mod, s.File, int64(id)*int64(size), size, prot)
+	if err != nil {
+		return 0, err
+	}
+	s.regions = append(s.regions, r)
+	return r.Ptr, nil
+}
+
+func (s *vfsShm) shmLock(offset, n int32, flags _ShmFlag) error {
+	// Argument check.
+	if n <= 0 || offset < 0 || offset+n > _SHM_NLOCK {
+		panic(util.AssertErr())
+	}
+	switch flags {
+	case
+		_SHM_LOCK | _SHM_SHARED,
+		_SHM_LOCK | _SHM_EXCLUSIVE,
+		_SHM_UNLOCK | _SHM_SHARED,
+		_SHM_UNLOCK | _SHM_EXCLUSIVE:
+		//
+	default:
+		panic(util.AssertErr())
+	}
+	if n != 1 && flags&_SHM_EXCLUSIVE == 0 {
+		panic(util.AssertErr())
+	}
+
+	switch {
+	case flags&_SHM_UNLOCK != 0:
+		return osUnlock(s.File, _SHM_BASE+int64(offset), int64(n))
+	case flags&_SHM_SHARED != 0:
+		return osReadLock(s.File, _SHM_BASE+int64(offset), int64(n), 0)
+	case flags&_SHM_EXCLUSIVE != 0:
+		return osWriteLock(s.File, _SHM_BASE+int64(offset), int64(n), 0)
+	default:
+		panic(util.AssertErr())
+	}
+}
+
+func (s *vfsShm) shmUnmap(delete bool) {
+	if s.File == nil {
+		return
+	}
+
+	// Unmap regions.
+	for _, r := range s.regions {
+		r.Unmap()
+	}
+	clear(s.regions)
+	s.regions = s.regions[:0]
+
+	// Close the file.
+	defer s.Close()
+	if delete {
+		os.Remove(s.Name())
+	}
+	s.File = nil
+}

vendor/github.com/ncruces/go-sqlite3/vfs/shm_other.go

@@ -0,0 +1,21 @@
+//go:build !(darwin || linux) || !(amd64 || arm64 || riscv64) || sqlite3_flock || sqlite3_noshm || sqlite3_nosys
+
+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 = false
+
+// 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 {
+	return nil
+}

vendor/github.com/ncruces/go-sqlite3/vfs/vfs.go

@@ -4,8 +4,8 @@ import (
 	"context"
 	"crypto/rand"
 	"io"
-	"net/url"
 	"reflect"
+	"sync"
 	"time"
 
 	"github.com/ncruces/go-sqlite3/internal/util"
@@ -23,12 +23,11 @@ func ExportHostFunctions(env wazero.HostModuleBuilder) wazero.HostModuleBuilder
 	util.ExportFuncIIJ(env, "go_localtime", vfsLocaltime)
 	util.ExportFuncIIII(env, "go_randomness", vfsRandomness)
 	util.ExportFuncIII(env, "go_sleep", vfsSleep)
-	util.ExportFuncIII(env, "go_current_time", vfsCurrentTime)
 	util.ExportFuncIII(env, "go_current_time_64", vfsCurrentTime64)
 	util.ExportFuncIIIII(env, "go_full_pathname", vfsFullPathname)
 	util.ExportFuncIIII(env, "go_delete", vfsDelete)
 	util.ExportFuncIIIII(env, "go_access", vfsAccess)
-	util.ExportFuncIIIIII(env, "go_open", vfsOpen)
+	util.ExportFuncIIIIIII(env, "go_open", vfsOpen)
 	util.ExportFuncII(env, "go_close", vfsClose)
 	util.ExportFuncIIIIJ(env, "go_read", vfsRead)
 	util.ExportFuncIIIIJ(env, "go_write", vfsWrite)
@@ -41,38 +40,15 @@ func ExportHostFunctions(env wazero.HostModuleBuilder) wazero.HostModuleBuilder
 	util.ExportFuncIII(env, "go_lock", vfsLock)
 	util.ExportFuncIII(env, "go_unlock", vfsUnlock)
 	util.ExportFuncIII(env, "go_check_reserved_lock", vfsCheckReservedLock)
+	util.ExportFuncIIIIII(env, "go_shm_map", vfsShmMap)
+	util.ExportFuncIIIII(env, "go_shm_lock", vfsShmLock)
+	util.ExportFuncIII(env, "go_shm_unmap", vfsShmUnmap)
+	util.ExportFuncVI(env, "go_shm_barrier", vfsShmBarrier)
 	return env
 }
 
-type vfsKey struct{}
-type vfsState struct {
-	files []File
-}
-
-// NewContext is an internal API users need not call directly.
-//
-// NewContext creates a new context to hold [api.Module] specific VFS data.
-// The context should be passed to any [api.Function] calls that might
-// generate VFS host callbacks.
-// The returned [io.Closer] should be closed after the [api.Module] is closed,
-// to release any associated resources.
-func NewContext(ctx context.Context) (context.Context, io.Closer) {
-	vfs := new(vfsState)
-	return context.WithValue(ctx, vfsKey{}, vfs), vfs
-}
-
-func (vfs *vfsState) Close() error {
-	for _, f := range vfs.files {
-		if f != nil {
-			f.Close()
-		}
-	}
-	vfs.files = nil
-	return nil
-}
-
 func vfsFind(ctx context.Context, mod api.Module, zVfsName uint32) uint32 {
-	name := util.ReadString(mod, zVfsName, _MAX_STRING)
+	name := util.ReadString(mod, zVfsName, _MAX_NAME)
 	if vfs := Find(name); vfs != nil && vfs != (vfsOS{}) {
 		return 1
 	}
@@ -100,20 +76,14 @@ func vfsLocaltime(ctx context.Context, mod api.Module, pTm uint32, t int64) _Err
 	return _OK
 }
 
-func vfsRandomness(ctx context.Context, mod api.Module, pVfs, nByte, zByte uint32) uint32 {
+func vfsRandomness(ctx context.Context, mod api.Module, pVfs uint32, nByte int32, zByte uint32) uint32 {
 	mem := util.View(mod, zByte, uint64(nByte))
 	n, _ := rand.Reader.Read(mem)
 	return uint32(n)
 }
 
-func vfsSleep(ctx context.Context, mod api.Module, pVfs, nMicro uint32) _ErrorCode {
-	time.Sleep(time.Duration(nMicro) * time.Microsecond)
-	return _OK
-}
-
-func vfsCurrentTime(ctx context.Context, mod api.Module, pVfs, prNow uint32) _ErrorCode {
-	day := julianday.Float(time.Now())
-	util.WriteFloat64(mod, prNow, day)
+func vfsSleep(ctx context.Context, mod api.Module, pVfs uint32, nMicro int32) _ErrorCode {
+	osSleep(time.Duration(nMicro) * time.Microsecond)
 	return _OK
 }
 
@@ -124,19 +94,16 @@ func vfsCurrentTime64(ctx context.Context, mod api.Module, pVfs, piNow uint32) _
 	return _OK
 }
 
-func vfsFullPathname(ctx context.Context, mod api.Module, pVfs, zRelative, nFull, zFull uint32) _ErrorCode {
+func vfsFullPathname(ctx context.Context, mod api.Module, pVfs, zRelative uint32, nFull int32, zFull uint32) _ErrorCode {
 	vfs := vfsGet(mod, pVfs)
 	path := util.ReadString(mod, zRelative, _MAX_PATHNAME)
 
 	path, err := vfs.FullPathname(path)
 
-	size := uint64(len(path) + 1)
-	if size > uint64(nFull) {
+	if len(path) >= int(nFull) {
 		return _CANTOPEN_FULLPATH
 	}
-	mem := util.View(mod, zFull, size)
-	mem[len(path)] = 0
-	copy(mem, path)
+	util.WriteString(mod, zFull, path)
 
 	return vfsErrorCode(err, _CANTOPEN_FULLPATH)
 }
@@ -163,7 +130,7 @@ func vfsAccess(ctx context.Context, mod api.Module, pVfs, zPath uint32, flags Ac
 	return vfsErrorCode(err, _IOERR_ACCESS)
 }
 
-func vfsOpen(ctx context.Context, mod api.Module, pVfs, zPath, pFile uint32, flags OpenFlag, pOutFlags uint32) _ErrorCode {
+func vfsOpen(ctx context.Context, mod api.Module, pVfs, zPath, pFile uint32, flags OpenFlag, pOutFlags, pOutVFS uint32) _ErrorCode {
 	vfs := vfsGet(mod, pVfs)
 
 	var path string
@@ -173,33 +140,30 @@ func vfsOpen(ctx context.Context, mod api.Module, pVfs, zPath, pFile uint32, fla
 
 	var file File
 	var err error
-	var parsed bool
-	var params url.Values
-	if pfs, ok := vfs.(VFSParams); ok {
-		parsed = true
-		params = vfsURIParameters(ctx, mod, zPath, flags)
-		file, flags, err = pfs.OpenParams(path, flags, params)
+	if ffs, ok := vfs.(VFSFilename); ok {
+		name := OpenFilename(ctx, mod, zPath, flags)
+		file, flags, err = ffs.OpenFilename(name, flags)
 	} else {
 		file, flags, err = vfs.Open(path, flags)
 	}
-
-	if file, ok := file.(FilePowersafeOverwrite); ok {
-		if !parsed {
-			params = vfsURIParameters(ctx, mod, zPath, flags)
-		}
-		if b, ok := util.ParseBool(params.Get("psow")); ok {
-			file.SetPowersafeOverwrite(b)
-		}
-	}
-
 	if err != nil {
 		return vfsErrorCode(err, _CANTOPEN)
 	}
 
-	vfsFileRegister(ctx, mod, pFile, file)
+	if file, ok := file.(FilePowersafeOverwrite); ok {
+		name := OpenFilename(ctx, mod, zPath, flags)
+		if b, ok := util.ParseBool(name.URIParameter("psow")); ok {
+			file.SetPowersafeOverwrite(b)
+		}
+	}
+	if file, ok := file.(FileSharedMemory); ok &&
+		pOutVFS != 0 && file.SharedMemory() != nil {
+		util.WriteUint32(mod, pOutVFS, 1)
+	}
 	if pOutFlags != 0 {
 		util.WriteUint32(mod, pOutFlags, uint32(flags))
 	}
+	vfsFileRegister(ctx, mod, pFile, file)
 	return _OK
 }
 
@@ -211,8 +175,8 @@ func vfsClose(ctx context.Context, mod api.Module, pFile uint32) _ErrorCode {
 	return _OK
 }
 
-func vfsRead(ctx context.Context, mod api.Module, pFile, zBuf, iAmt uint32, iOfst int64) _ErrorCode {
-	file := vfsFileGet(ctx, mod, pFile)
+func vfsRead(ctx context.Context, mod api.Module, pFile, zBuf uint32, iAmt int32, iOfst int64) _ErrorCode {
+	file := vfsFileGet(ctx, mod, pFile).(File)
 	buf := util.View(mod, zBuf, uint64(iAmt))
 
 	n, err := file.ReadAt(buf, iOfst)
@@ -226,8 +190,8 @@ func vfsRead(ctx context.Context, mod api.Module, pFile, zBuf, iAmt uint32, iOfs
 	return _IOERR_SHORT_READ
 }
 
-func vfsWrite(ctx context.Context, mod api.Module, pFile, zBuf, iAmt uint32, iOfst int64) _ErrorCode {
-	file := vfsFileGet(ctx, mod, pFile)
+func vfsWrite(ctx context.Context, mod api.Module, pFile, zBuf uint32, iAmt int32, iOfst int64) _ErrorCode {
+	file := vfsFileGet(ctx, mod, pFile).(File)
 	buf := util.View(mod, zBuf, uint64(iAmt))
 
 	_, err := file.WriteAt(buf, iOfst)
@@ -238,38 +202,38 @@ func vfsWrite(ctx context.Context, mod api.Module, pFile, zBuf, iAmt uint32, iOf
 }
 
 func vfsTruncate(ctx context.Context, mod api.Module, pFile uint32, nByte int64) _ErrorCode {
-	file := vfsFileGet(ctx, mod, pFile)
+	file := vfsFileGet(ctx, mod, pFile).(File)
 	err := file.Truncate(nByte)
 	return vfsErrorCode(err, _IOERR_TRUNCATE)
 }
 
 func vfsSync(ctx context.Context, mod api.Module, pFile uint32, flags SyncFlag) _ErrorCode {
-	file := vfsFileGet(ctx, mod, pFile)
+	file := vfsFileGet(ctx, mod, pFile).(File)
 	err := file.Sync(flags)
 	return vfsErrorCode(err, _IOERR_FSYNC)
 }
 
 func vfsFileSize(ctx context.Context, mod api.Module, pFile, pSize uint32) _ErrorCode {
-	file := vfsFileGet(ctx, mod, pFile)
+	file := vfsFileGet(ctx, mod, pFile).(File)
 	size, err := file.Size()
 	util.WriteUint64(mod, pSize, uint64(size))
 	return vfsErrorCode(err, _IOERR_SEEK)
 }
 
 func vfsLock(ctx context.Context, mod api.Module, pFile uint32, eLock LockLevel) _ErrorCode {
-	file := vfsFileGet(ctx, mod, pFile)
+	file := vfsFileGet(ctx, mod, pFile).(File)
 	err := file.Lock(eLock)
 	return vfsErrorCode(err, _IOERR_LOCK)
 }
 
 func vfsUnlock(ctx context.Context, mod api.Module, pFile uint32, eLock LockLevel) _ErrorCode {
-	file := vfsFileGet(ctx, mod, pFile)
+	file := vfsFileGet(ctx, mod, pFile).(File)
 	err := file.Unlock(eLock)
 	return vfsErrorCode(err, _IOERR_UNLOCK)
 }
 
 func vfsCheckReservedLock(ctx context.Context, mod api.Module, pFile, pResOut uint32) _ErrorCode {
-	file := vfsFileGet(ctx, mod, pFile)
+	file := vfsFileGet(ctx, mod, pFile).(File)
 	locked, err := file.CheckReservedLock()
 
 	var res uint32
@@ -282,7 +246,7 @@ func vfsCheckReservedLock(ctx context.Context, mod api.Module, pFile, pResOut ui
 }
 
 func vfsFileControl(ctx context.Context, mod api.Module, pFile uint32, op _FcntlOpcode, pArg uint32) _ErrorCode {
-	file := vfsFileGet(ctx, mod, pFile)
+	file := vfsFileGet(ctx, mod, pFile).(File)
 
 	switch op {
 	case _FCNTL_LOCKSTATE:
@@ -291,31 +255,37 @@ func vfsFileControl(ctx context.Context, mod api.Module, pFile uint32, op _Fcntl
 			return _OK
 		}
 
-	case _FCNTL_LOCK_TIMEOUT:
-		if file, ok := file.(*vfsFile); ok {
-			millis := file.lockTimeout.Milliseconds()
-			file.lockTimeout = time.Duration(util.ReadUint32(mod, pArg)) * time.Millisecond
-			util.WriteUint32(mod, pArg, uint32(millis))
+	case _FCNTL_PERSIST_WAL:
+		if file, ok := file.(FilePersistentWAL); ok {
+			if i := util.ReadUint32(mod, pArg); int32(i) >= 0 {
+				file.SetPersistentWAL(i != 0)
+			} else if file.PersistentWAL() {
+				util.WriteUint32(mod, pArg, 1)
+			} else {
+				util.WriteUint32(mod, pArg, 0)
+			}
 			return _OK
 		}
 
 	case _FCNTL_POWERSAFE_OVERWRITE:
 		if file, ok := file.(FilePowersafeOverwrite); ok {
-			switch util.ReadUint32(mod, pArg) {
-			case 0:
-				file.SetPowersafeOverwrite(false)
-			case 1:
-				file.SetPowersafeOverwrite(true)
-			default:
-				if file.PowersafeOverwrite() {
-					util.WriteUint32(mod, pArg, 1)
-				} else {
-					util.WriteUint32(mod, pArg, 0)
-				}
+			if i := util.ReadUint32(mod, pArg); int32(i) >= 0 {
+				file.SetPowersafeOverwrite(i != 0)
+			} else if file.PowersafeOverwrite() {
+				util.WriteUint32(mod, pArg, 1)
+			} else {
+				util.WriteUint32(mod, pArg, 0)
 			}
 			return _OK
 		}
 
+	case _FCNTL_CHUNK_SIZE:
+		if file, ok := file.(FileChunkSize); ok {
+			size := util.ReadUint32(mod, pArg)
+			file.ChunkSize(int(size))
+			return _OK
+		}
+
 	case _FCNTL_SIZE_HINT:
 		if file, ok := file.(FileSizeHint); ok {
 			size := util.ReadUint64(mod, pArg)
@@ -326,16 +296,20 @@ func vfsFileControl(ctx context.Context, mod api.Module, pFile uint32, op _Fcntl
 	case _FCNTL_HAS_MOVED:
 		if file, ok := file.(FileHasMoved); ok {
 			moved, err := file.HasMoved()
-
 			var res uint32
 			if moved {
 				res = 1
 			}
-
 			util.WriteUint32(mod, pArg, res)
 			return vfsErrorCode(err, _IOERR_FSTAT)
 		}
 
+	case _FCNTL_OVERWRITE:
+		if file, ok := file.(FileOverwrite); ok {
+			err := file.Overwrite()
+			return vfsErrorCode(err, _IOERR)
+		}
+
 	case _FCNTL_COMMIT_PHASETWO:
 		if file, ok := file.(FileCommitPhaseTwo); ok {
 			err := file.CommitPhaseTwo()
@@ -357,73 +331,97 @@ func vfsFileControl(ctx context.Context, mod api.Module, pFile uint32, op _Fcntl
 			err := file.RollbackAtomicWrite()
 			return vfsErrorCode(err, _IOERR_ROLLBACK_ATOMIC)
 		}
+
+	case _FCNTL_CKPT_DONE:
+		if file, ok := file.(FileCheckpoint); ok {
+			err := file.CheckpointDone()
+			return vfsErrorCode(err, _IOERR)
+		}
+	case _FCNTL_CKPT_START:
+		if file, ok := file.(FileCheckpoint); ok {
+			err := file.CheckpointStart()
+			return vfsErrorCode(err, _IOERR)
+		}
+
+	case _FCNTL_PRAGMA:
+		if file, ok := file.(FilePragma); ok {
+			ptr := util.ReadUint32(mod, pArg+1*ptrlen)
+			name := util.ReadString(mod, ptr, _MAX_SQL_LENGTH)
+			var value string
+			if ptr := util.ReadUint32(mod, pArg+2*ptrlen); ptr != 0 {
+				value = util.ReadString(mod, ptr, _MAX_SQL_LENGTH)
+			}
+
+			out, err := file.Pragma(name, value)
+
+			ret := vfsErrorCode(err, _ERROR)
+			if ret == _ERROR {
+				out = err.Error()
+			}
+			if out != "" {
+				fn := mod.ExportedFunction("malloc")
+				stack := [...]uint64{uint64(len(out) + 1)}
+				if err := fn.CallWithStack(ctx, stack[:]); err != nil {
+					panic(err)
+				}
+				util.WriteUint32(mod, pArg, uint32(stack[0]))
+				util.WriteString(mod, uint32(stack[0]), out)
+			}
+			return ret
+		}
 	}
 
 	// Consider also implementing these opcodes (in use by SQLite):
-	//  _FCNTL_PDB
 	//  _FCNTL_BUSYHANDLER
-	//  _FCNTL_CHUNK_SIZE
-	//  _FCNTL_OVERWRITE
-	//  _FCNTL_PRAGMA
+	//  _FCNTL_LAST_ERRNO
 	//  _FCNTL_SYNC
 	return _NOTFOUND
 }
 
 func vfsSectorSize(ctx context.Context, mod api.Module, pFile uint32) uint32 {
-	file := vfsFileGet(ctx, mod, pFile)
+	file := vfsFileGet(ctx, mod, pFile).(File)
 	return uint32(file.SectorSize())
 }
 
 func vfsDeviceCharacteristics(ctx context.Context, mod api.Module, pFile uint32) DeviceCharacteristic {
-	file := vfsFileGet(ctx, mod, pFile)
+	file := vfsFileGet(ctx, mod, pFile).(File)
 	return file.DeviceCharacteristics()
 }
 
-func vfsURIParameters(ctx context.Context, mod api.Module, zPath uint32, flags OpenFlag) url.Values {
-	if flags&OPEN_URI == 0 {
-		return nil
+var shmBarrier sync.Mutex
+
+func vfsShmBarrier(ctx context.Context, mod api.Module, pFile uint32) {
+	shmBarrier.Lock()
+	defer shmBarrier.Unlock()
+}
+
+func vfsShmMap(ctx context.Context, mod api.Module, pFile uint32, iRegion, szRegion int32, bExtend, pp uint32) _ErrorCode {
+	shm := vfsFileGet(ctx, mod, pFile).(FileSharedMemory).SharedMemory()
+	p, err := shm.shmMap(ctx, mod, iRegion, szRegion, bExtend != 0)
+	if err != nil {
+		return vfsErrorCode(err, _IOERR_SHMMAP)
 	}
+	util.WriteUint32(mod, pp, p)
+	return _OK
+}
 
-	uriParam := mod.ExportedFunction("sqlite3_uri_parameter")
-	uriKey := mod.ExportedFunction("sqlite3_uri_key")
-	if uriParam == nil || uriKey == nil {
-		return nil
-	}
+func vfsShmLock(ctx context.Context, mod api.Module, pFile uint32, offset, n int32, flags _ShmFlag) _ErrorCode {
+	shm := vfsFileGet(ctx, mod, pFile).(FileSharedMemory).SharedMemory()
+	err := shm.shmLock(offset, n, flags)
+	return vfsErrorCode(err, _IOERR_SHMLOCK)
+}
 
-	var stack [2]uint64
-	var params url.Values
-
-	for i := 0; ; i++ {
-		stack[1] = uint64(i)
-		stack[0] = uint64(zPath)
-		if err := uriKey.CallWithStack(ctx, stack[:]); err != nil {
-			panic(err)
-		}
-		if stack[0] == 0 {
-			return params
-		}
-		key := util.ReadString(mod, uint32(stack[0]), _MAX_STRING)
-		if params.Has(key) {
-			continue
-		}
-
-		stack[1] = stack[0]
-		stack[0] = uint64(zPath)
-		if err := uriParam.CallWithStack(ctx, stack[:]); err != nil {
-			panic(err)
-		}
-		if params == nil {
-			params = url.Values{}
-		}
-		params.Set(key, util.ReadString(mod, uint32(stack[0]), _MAX_STRING))
-	}
+func vfsShmUnmap(ctx context.Context, mod api.Module, pFile, bDelete uint32) _ErrorCode {
+	shm := vfsFileGet(ctx, mod, pFile).(FileSharedMemory).SharedMemory()
+	shm.shmUnmap(bDelete != 0)
+	return _OK
 }
 
 func vfsGet(mod api.Module, pVfs uint32) VFS {
 	var name string
 	if pVfs != 0 {
 		const zNameOffset = 16
-		name = util.ReadString(mod, util.ReadUint32(mod, pVfs+zNameOffset), _MAX_STRING)
+		name = util.ReadString(mod, util.ReadUint32(mod, pVfs+zNameOffset), _MAX_NAME)
 	}
 	if vfs := Find(name); vfs != nil {
 		return vfs
@@ -431,40 +429,22 @@ func vfsGet(mod api.Module, pVfs uint32) VFS {
 	panic(util.NoVFSErr + util.ErrorString(name))
 }
 
-func vfsFileNew(vfs *vfsState, file File) uint32 {
-	// Find an empty slot.
-	for id, f := range vfs.files {
-		if f == nil {
-			vfs.files[id] = file
-			return uint32(id)
-		}
-	}
-
-	// Add a new slot.
-	vfs.files = append(vfs.files, file)
-	return uint32(len(vfs.files) - 1)
-}
-
 func vfsFileRegister(ctx context.Context, mod api.Module, pFile uint32, file File) {
 	const fileHandleOffset = 4
-	id := vfsFileNew(ctx.Value(vfsKey{}).(*vfsState), file)
+	id := util.AddHandle(ctx, file)
 	util.WriteUint32(mod, pFile+fileHandleOffset, id)
 }
 
-func vfsFileGet(ctx context.Context, mod api.Module, pFile uint32) File {
+func vfsFileGet(ctx context.Context, mod api.Module, pFile uint32) any {
 	const fileHandleOffset = 4
-	vfs := ctx.Value(vfsKey{}).(*vfsState)
 	id := util.ReadUint32(mod, pFile+fileHandleOffset)
-	return vfs.files[id]
+	return util.GetHandle(ctx, id)
 }
 
 func vfsFileClose(ctx context.Context, mod api.Module, pFile uint32) error {
 	const fileHandleOffset = 4
-	vfs := ctx.Value(vfsKey{}).(*vfsState)
 	id := util.ReadUint32(mod, pFile+fileHandleOffset)
-	file := vfs.files[id]
-	vfs.files[id] = nil
-	return file.Close()
+	return util.DelHandle(ctx, id)
 }
 
 func vfsErrorCode(err error, def _ErrorCode) _ErrorCode {
@@ -477,9 +457,3 @@ func vfsErrorCode(err error, def _ErrorCode) _ErrorCode {
 	}
 	return def
 }
-
-func clear(b []byte) {
-	for i := range b {
-		b[i] = 0
-	}
-}

vendor/github.com/ncruces/go-sqlite3/vtab.go

@@ -0,0 +1,663 @@
+package sqlite3
+
+import (
+	"context"
+	"reflect"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/tetratelabs/wazero/api"
+)
+
+// CreateModule registers a new virtual table module name.
+// If create is nil, the virtual table is eponymous.
+//
+// https://sqlite.org/c3ref/create_module.html
+func CreateModule[T VTab](db *Conn, name string, create, connect VTabConstructor[T]) error {
+	var flags int
+
+	const (
+		VTAB_CREATOR     = 0x01
+		VTAB_DESTROYER   = 0x02
+		VTAB_UPDATER     = 0x04
+		VTAB_RENAMER     = 0x08
+		VTAB_OVERLOADER  = 0x10
+		VTAB_CHECKER     = 0x20
+		VTAB_TXN         = 0x40
+		VTAB_SAVEPOINTER = 0x80
+	)
+
+	if create != nil {
+		flags |= VTAB_CREATOR
+	}
+
+	vtab := reflect.TypeOf(connect).Out(0)
+	if implements[VTabDestroyer](vtab) {
+		flags |= VTAB_DESTROYER
+	}
+	if implements[VTabUpdater](vtab) {
+		flags |= VTAB_UPDATER
+	}
+	if implements[VTabRenamer](vtab) {
+		flags |= VTAB_RENAMER
+	}
+	if implements[VTabOverloader](vtab) {
+		flags |= VTAB_OVERLOADER
+	}
+	if implements[VTabChecker](vtab) {
+		flags |= VTAB_CHECKER
+	}
+	if implements[VTabTxn](vtab) {
+		flags |= VTAB_TXN
+	}
+	if implements[VTabSavepointer](vtab) {
+		flags |= VTAB_SAVEPOINTER
+	}
+
+	defer db.arena.mark()()
+	namePtr := db.arena.string(name)
+	modulePtr := util.AddHandle(db.ctx, module[T]{create, connect})
+	r := db.call("sqlite3_create_module_go", uint64(db.handle),
+		uint64(namePtr), uint64(flags), uint64(modulePtr))
+	return db.error(r)
+}
+
+func implements[T any](typ reflect.Type) bool {
+	var ptr *T
+	return typ.Implements(reflect.TypeOf(ptr).Elem())
+}
+
+// DeclareVTab declares the schema of a virtual table.
+//
+// https://sqlite.org/c3ref/declare_vtab.html
+func (c *Conn) DeclareVTab(sql string) error {
+	defer c.arena.mark()()
+	sqlPtr := c.arena.string(sql)
+	r := c.call("sqlite3_declare_vtab", uint64(c.handle), uint64(sqlPtr))
+	return c.error(r)
+}
+
+// VTabConflictMode is a virtual table conflict resolution mode.
+//
+// https://sqlite.org/c3ref/c_fail.html
+type VTabConflictMode uint8
+
+const (
+	VTAB_ROLLBACK VTabConflictMode = 1
+	VTAB_IGNORE   VTabConflictMode = 2
+	VTAB_FAIL     VTabConflictMode = 3
+	VTAB_ABORT    VTabConflictMode = 4
+	VTAB_REPLACE  VTabConflictMode = 5
+)
+
+// VTabOnConflict determines the virtual table conflict policy.
+//
+// https://sqlite.org/c3ref/vtab_on_conflict.html
+func (c *Conn) VTabOnConflict() VTabConflictMode {
+	r := c.call("sqlite3_vtab_on_conflict", uint64(c.handle))
+	return VTabConflictMode(r)
+}
+
+// VTabConfigOption is a virtual table configuration option.
+//
+// https://sqlite.org/c3ref/c_vtab_constraint_support.html
+type VTabConfigOption uint8
+
+const (
+	VTAB_CONSTRAINT_SUPPORT VTabConfigOption = 1
+	VTAB_INNOCUOUS          VTabConfigOption = 2
+	VTAB_DIRECTONLY         VTabConfigOption = 3
+	VTAB_USES_ALL_SCHEMAS   VTabConfigOption = 4
+)
+
+// VTabConfig configures various facets of the virtual table interface.
+//
+// https://sqlite.org/c3ref/vtab_config.html
+func (c *Conn) VTabConfig(op VTabConfigOption, args ...any) error {
+	var i uint64
+	if op == VTAB_CONSTRAINT_SUPPORT && len(args) > 0 {
+		if b, ok := args[0].(bool); ok && b {
+			i = 1
+		}
+	}
+	r := c.call("sqlite3_vtab_config_go", uint64(c.handle), uint64(op), i)
+	return c.error(r)
+}
+
+// VTabConstructor is a virtual table constructor function.
+type VTabConstructor[T VTab] func(db *Conn, module, schema, table string, arg ...string) (T, error)
+
+type module[T VTab] [2]VTabConstructor[T]
+
+type vtabConstructor int
+
+const (
+	xCreate  vtabConstructor = 0
+	xConnect vtabConstructor = 1
+)
+
+// A VTab describes a particular instance of the virtual table.
+// A VTab may optionally implement [io.Closer] to free resources.
+//
+// https://sqlite.org/c3ref/vtab.html
+type VTab interface {
+	// https://sqlite.org/vtab.html#xbestindex
+	BestIndex(*IndexInfo) error
+	// https://sqlite.org/vtab.html#xopen
+	Open() (VTabCursor, error)
+}
+
+// A VTabDestroyer allows a virtual table to drop persistent state.
+type VTabDestroyer interface {
+	VTab
+	// https://sqlite.org/vtab.html#sqlite3_module.xDestroy
+	Destroy() error
+}
+
+// A VTabUpdater allows a virtual table to be updated.
+type VTabUpdater interface {
+	VTab
+	// https://sqlite.org/vtab.html#xupdate
+	Update(arg ...Value) (rowid int64, err error)
+}
+
+// A VTabRenamer allows a virtual table to be renamed.
+type VTabRenamer interface {
+	VTab
+	// https://sqlite.org/vtab.html#xrename
+	Rename(new string) error
+}
+
+// A VTabOverloader allows a virtual table to overload SQL functions.
+type VTabOverloader interface {
+	VTab
+	// https://sqlite.org/vtab.html#xfindfunction
+	FindFunction(arg int, name string) (ScalarFunction, IndexConstraintOp)
+}
+
+// A VTabChecker allows a virtual table to report errors
+// to the PRAGMA integrity_check and PRAGMA quick_check commands.
+//
+// Integrity should return an error if it finds problems in the content of the virtual table,
+// but should avoid returning a (wrapped) [Error], [ErrorCode] or [ExtendedErrorCode],
+// as those indicate the Integrity method itself encountered problems
+// while trying to evaluate the virtual table content.
+type VTabChecker interface {
+	VTab
+	// https://sqlite.org/vtab.html#xintegrity
+	Integrity(schema, table string, flags int) error
+}
+
+// A VTabTxn allows a virtual table to implement
+// transactions with two-phase commit.
+//
+// Anything that is required as part of a commit that may fail
+// should be performed in the Sync() callback.
+// Current versions of SQLite ignore any errors
+// returned by Commit() and Rollback().
+type VTabTxn interface {
+	VTab
+	// https://sqlite.org/vtab.html#xBegin
+	Begin() error
+	// https://sqlite.org/vtab.html#xsync
+	Sync() error
+	// https://sqlite.org/vtab.html#xcommit
+	Commit() error
+	// https://sqlite.org/vtab.html#xrollback
+	Rollback() error
+}
+
+// A VTabSavepointer allows a virtual table to implement
+// nested transactions.
+//
+// https://sqlite.org/vtab.html#xsavepoint
+type VTabSavepointer interface {
+	VTabTxn
+	Savepoint(id int) error
+	Release(id int) error
+	RollbackTo(id int) error
+}
+
+// A VTabCursor describes cursors that point
+// into the virtual table and are used
+// to loop through the virtual table.
+// A VTabCursor may optionally implement
+// [io.Closer] to free resources.
+//
+// http://sqlite.org/c3ref/vtab_cursor.html
+type VTabCursor interface {
+	// https://sqlite.org/vtab.html#xfilter
+	Filter(idxNum int, idxStr string, arg ...Value) error
+	// https://sqlite.org/vtab.html#xnext
+	Next() error
+	// https://sqlite.org/vtab.html#xeof
+	EOF() bool
+	// https://sqlite.org/vtab.html#xcolumn
+	Column(ctx *Context, n int) error
+	// https://sqlite.org/vtab.html#xrowid
+	RowID() (int64, error)
+}
+
+// An IndexInfo describes virtual table indexing information.
+//
+// https://sqlite.org/c3ref/index_info.html
+type IndexInfo struct {
+	// Inputs
+	Constraint  []IndexConstraint
+	OrderBy     []IndexOrderBy
+	ColumnsUsed int64
+	// Outputs
+	ConstraintUsage []IndexConstraintUsage
+	IdxNum          int
+	IdxStr          string
+	IdxFlags        IndexScanFlag
+	OrderByConsumed bool
+	EstimatedCost   float64
+	EstimatedRows   int64
+	// Internal
+	c      *Conn
+	handle uint32
+}
+
+// An IndexConstraint describes virtual table indexing constraint information.
+//
+// https://sqlite.org/c3ref/index_info.html
+type IndexConstraint struct {
+	Column int
+	Op     IndexConstraintOp
+	Usable bool
+}
+
+// An IndexOrderBy describes virtual table indexing order by information.
+//
+// https://sqlite.org/c3ref/index_info.html
+type IndexOrderBy struct {
+	Column int
+	Desc   bool
+}
+
+// An IndexConstraintUsage describes how virtual table indexing constraints will be used.
+//
+// https://sqlite.org/c3ref/index_info.html
+type IndexConstraintUsage struct {
+	ArgvIndex int
+	Omit      bool
+}
+
+// RHSValue returns the value of the right-hand operand of a constraint
+// if the right-hand operand is known.
+//
+// https://sqlite.org/c3ref/vtab_rhs_value.html
+func (idx *IndexInfo) RHSValue(column int) (Value, error) {
+	defer idx.c.arena.mark()()
+	valPtr := idx.c.arena.new(ptrlen)
+	r := idx.c.call("sqlite3_vtab_rhs_value", uint64(idx.handle),
+		uint64(column), uint64(valPtr))
+	if err := idx.c.error(r); err != nil {
+		return Value{}, err
+	}
+	return Value{
+		c:      idx.c,
+		handle: util.ReadUint32(idx.c.mod, valPtr),
+	}, nil
+}
+
+// Collation returns the name of the collation for a virtual table constraint.
+//
+// https://sqlite.org/c3ref/vtab_collation.html
+func (idx *IndexInfo) Collation(column int) string {
+	r := idx.c.call("sqlite3_vtab_collation", uint64(idx.handle),
+		uint64(column))
+	return util.ReadString(idx.c.mod, uint32(r), _MAX_NAME)
+}
+
+// Distinct determines if a virtual table query is DISTINCT.
+//
+// https://sqlite.org/c3ref/vtab_distinct.html
+func (idx *IndexInfo) Distinct() int {
+	r := idx.c.call("sqlite3_vtab_distinct", uint64(idx.handle))
+	return int(r)
+}
+
+// In identifies and handles IN constraints.
+//
+// https://sqlite.org/c3ref/vtab_in.html
+func (idx *IndexInfo) In(column, handle int) bool {
+	r := idx.c.call("sqlite3_vtab_in", uint64(idx.handle),
+		uint64(column), uint64(handle))
+	return r != 0
+}
+
+func (idx *IndexInfo) load() {
+	// https://sqlite.org/c3ref/index_info.html
+	mod := idx.c.mod
+	ptr := idx.handle
+
+	idx.Constraint = make([]IndexConstraint, util.ReadUint32(mod, ptr+0))
+	idx.ConstraintUsage = make([]IndexConstraintUsage, util.ReadUint32(mod, ptr+0))
+	idx.OrderBy = make([]IndexOrderBy, util.ReadUint32(mod, ptr+8))
+
+	constraintPtr := util.ReadUint32(mod, ptr+4)
+	for i := range idx.Constraint {
+		idx.Constraint[i] = IndexConstraint{
+			Column: int(int32(util.ReadUint32(mod, constraintPtr+0))),
+			Op:     IndexConstraintOp(util.ReadUint8(mod, constraintPtr+4)),
+			Usable: util.ReadUint8(mod, constraintPtr+5) != 0,
+		}
+		constraintPtr += 12
+	}
+
+	orderByPtr := util.ReadUint32(mod, ptr+12)
+	for i := range idx.OrderBy {
+		idx.OrderBy[i] = IndexOrderBy{
+			Column: int(int32(util.ReadUint32(mod, orderByPtr+0))),
+			Desc:   util.ReadUint8(mod, orderByPtr+4) != 0,
+		}
+		orderByPtr += 8
+	}
+
+	idx.EstimatedCost = util.ReadFloat64(mod, ptr+40)
+	idx.EstimatedRows = int64(util.ReadUint64(mod, ptr+48))
+	idx.ColumnsUsed = int64(util.ReadUint64(mod, ptr+64))
+}
+
+func (idx *IndexInfo) save() {
+	// https://sqlite.org/c3ref/index_info.html
+	mod := idx.c.mod
+	ptr := idx.handle
+
+	usagePtr := util.ReadUint32(mod, ptr+16)
+	for _, usage := range idx.ConstraintUsage {
+		util.WriteUint32(mod, usagePtr+0, uint32(usage.ArgvIndex))
+		if usage.Omit {
+			util.WriteUint8(mod, usagePtr+4, 1)
+		}
+		usagePtr += 8
+	}
+
+	util.WriteUint32(mod, ptr+20, uint32(idx.IdxNum))
+	if idx.IdxStr != "" {
+		util.WriteUint32(mod, ptr+24, idx.c.newString(idx.IdxStr))
+		util.WriteUint32(mod, ptr+28, 1) // needToFreeIdxStr
+	}
+	if idx.OrderByConsumed {
+		util.WriteUint32(mod, ptr+32, 1)
+	}
+	util.WriteFloat64(mod, ptr+40, idx.EstimatedCost)
+	util.WriteUint64(mod, ptr+48, uint64(idx.EstimatedRows))
+	util.WriteUint32(mod, ptr+56, uint32(idx.IdxFlags))
+}
+
+// IndexConstraintOp is a virtual table constraint operator code.
+//
+// https://sqlite.org/c3ref/c_index_constraint_eq.html
+type IndexConstraintOp uint8
+
+const (
+	INDEX_CONSTRAINT_EQ        IndexConstraintOp = 2
+	INDEX_CONSTRAINT_GT        IndexConstraintOp = 4
+	INDEX_CONSTRAINT_LE        IndexConstraintOp = 8
+	INDEX_CONSTRAINT_LT        IndexConstraintOp = 16
+	INDEX_CONSTRAINT_GE        IndexConstraintOp = 32
+	INDEX_CONSTRAINT_MATCH     IndexConstraintOp = 64
+	INDEX_CONSTRAINT_LIKE      IndexConstraintOp = 65
+	INDEX_CONSTRAINT_GLOB      IndexConstraintOp = 66
+	INDEX_CONSTRAINT_REGEXP    IndexConstraintOp = 67
+	INDEX_CONSTRAINT_NE        IndexConstraintOp = 68
+	INDEX_CONSTRAINT_ISNOT     IndexConstraintOp = 69
+	INDEX_CONSTRAINT_ISNOTNULL IndexConstraintOp = 70
+	INDEX_CONSTRAINT_ISNULL    IndexConstraintOp = 71
+	INDEX_CONSTRAINT_IS        IndexConstraintOp = 72
+	INDEX_CONSTRAINT_LIMIT     IndexConstraintOp = 73
+	INDEX_CONSTRAINT_OFFSET    IndexConstraintOp = 74
+	INDEX_CONSTRAINT_FUNCTION  IndexConstraintOp = 150
+)
+
+// IndexScanFlag is a virtual table scan flag.
+//
+// https://sqlite.org/c3ref/c_index_scan_unique.html
+type IndexScanFlag uint32
+
+const (
+	INDEX_SCAN_UNIQUE IndexScanFlag = 1
+)
+
+func vtabModuleCallback(i vtabConstructor) func(_ context.Context, _ api.Module, _, _, _, _, _ uint32) uint32 {
+	return func(ctx context.Context, mod api.Module, pMod, nArg, pArg, ppVTab, pzErr uint32) uint32 {
+		arg := make([]reflect.Value, 1+nArg)
+		arg[0] = reflect.ValueOf(ctx.Value(connKey{}))
+
+		for i := uint32(0); i < nArg; i++ {
+			ptr := util.ReadUint32(mod, pArg+i*ptrlen)
+			arg[i+1] = reflect.ValueOf(util.ReadString(mod, ptr, _MAX_SQL_LENGTH))
+		}
+
+		module := vtabGetHandle(ctx, mod, pMod)
+		res := reflect.ValueOf(module).Index(int(i)).Call(arg)
+		err, _ := res[1].Interface().(error)
+		if err == nil {
+			vtabPutHandle(ctx, mod, ppVTab, res[0].Interface())
+		}
+
+		return vtabError(ctx, mod, pzErr, _PTR_ERROR, err)
+	}
+}
+
+func vtabDisconnectCallback(ctx context.Context, mod api.Module, pVTab uint32) uint32 {
+	err := vtabDelHandle(ctx, mod, pVTab)
+	return vtabError(ctx, mod, 0, _PTR_ERROR, err)
+}
+
+func vtabDestroyCallback(ctx context.Context, mod api.Module, pVTab uint32) uint32 {
+	vtab := vtabGetHandle(ctx, mod, pVTab).(VTabDestroyer)
+	err := vtab.Destroy()
+	if cerr := vtabDelHandle(ctx, mod, pVTab); err == nil {
+		err = cerr
+	}
+	return vtabError(ctx, mod, 0, _PTR_ERROR, err)
+}
+
+func vtabBestIndexCallback(ctx context.Context, mod api.Module, pVTab, pIdxInfo uint32) uint32 {
+	var info IndexInfo
+	info.handle = pIdxInfo
+	info.c = ctx.Value(connKey{}).(*Conn)
+	info.load()
+
+	vtab := vtabGetHandle(ctx, mod, pVTab).(VTab)
+	err := vtab.BestIndex(&info)
+
+	info.save()
+	return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
+}
+
+func vtabUpdateCallback(ctx context.Context, mod api.Module, pVTab, nArg, pArg, pRowID uint32) uint32 {
+	vtab := vtabGetHandle(ctx, mod, pVTab).(VTabUpdater)
+
+	db := ctx.Value(connKey{}).(*Conn)
+	args := make([]Value, nArg)
+	callbackArgs(db, args, pArg)
+	rowID, err := vtab.Update(args...)
+	if err == nil {
+		util.WriteUint64(mod, pRowID, uint64(rowID))
+	}
+
+	return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
+}
+
+func vtabRenameCallback(ctx context.Context, mod api.Module, pVTab, zNew uint32) uint32 {
+	vtab := vtabGetHandle(ctx, mod, pVTab).(VTabRenamer)
+	err := vtab.Rename(util.ReadString(mod, zNew, _MAX_NAME))
+	return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
+}
+
+func vtabFindFuncCallback(ctx context.Context, mod api.Module, pVTab uint32, nArg int32, zName, pxFunc uint32) uint32 {
+	vtab := vtabGetHandle(ctx, mod, pVTab).(VTabOverloader)
+	f, op := vtab.FindFunction(int(nArg), util.ReadString(mod, zName, _MAX_NAME))
+	if op != 0 {
+		var wrapper uint32
+		wrapper = util.AddHandle(ctx, func(c Context, arg ...Value) {
+			defer util.DelHandle(ctx, wrapper)
+			f(c, arg...)
+		})
+		util.WriteUint32(mod, pxFunc, wrapper)
+	}
+	return uint32(op)
+}
+
+func vtabIntegrityCallback(ctx context.Context, mod api.Module, pVTab, zSchema, zTabName, mFlags, pzErr uint32) uint32 {
+	vtab := vtabGetHandle(ctx, mod, pVTab).(VTabChecker)
+	schema := util.ReadString(mod, zSchema, _MAX_NAME)
+	table := util.ReadString(mod, zTabName, _MAX_NAME)
+	err := vtab.Integrity(schema, table, int(mFlags))
+	// xIntegrity should return OK - even if it finds problems in the content of the virtual table.
+	// https://sqlite.org/vtab.html#xintegrity
+	vtabError(ctx, mod, pzErr, _PTR_ERROR, err)
+	_, code := errorCode(err, _OK)
+	return code
+}
+
+func vtabBeginCallback(ctx context.Context, mod api.Module, pVTab uint32) uint32 {
+	vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTxn)
+	err := vtab.Begin()
+	return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
+}
+
+func vtabSyncCallback(ctx context.Context, mod api.Module, pVTab uint32) uint32 {
+	vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTxn)
+	err := vtab.Sync()
+	return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
+}
+
+func vtabCommitCallback(ctx context.Context, mod api.Module, pVTab uint32) uint32 {
+	vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTxn)
+	err := vtab.Commit()
+	return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
+}
+
+func vtabRollbackCallback(ctx context.Context, mod api.Module, pVTab uint32) uint32 {
+	vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTxn)
+	err := vtab.Rollback()
+	return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
+}
+
+func vtabSavepointCallback(ctx context.Context, mod api.Module, pVTab uint32, id int32) uint32 {
+	vtab := vtabGetHandle(ctx, mod, pVTab).(VTabSavepointer)
+	err := vtab.Savepoint(int(id))
+	return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
+}
+
+func vtabReleaseCallback(ctx context.Context, mod api.Module, pVTab uint32, id int32) uint32 {
+	vtab := vtabGetHandle(ctx, mod, pVTab).(VTabSavepointer)
+	err := vtab.Release(int(id))
+	return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
+}
+
+func vtabRollbackToCallback(ctx context.Context, mod api.Module, pVTab uint32, id int32) uint32 {
+	vtab := vtabGetHandle(ctx, mod, pVTab).(VTabSavepointer)
+	err := vtab.RollbackTo(int(id))
+	return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
+}
+
+func cursorOpenCallback(ctx context.Context, mod api.Module, pVTab, ppCur uint32) uint32 {
+	vtab := vtabGetHandle(ctx, mod, pVTab).(VTab)
+
+	cursor, err := vtab.Open()
+	if err == nil {
+		vtabPutHandle(ctx, mod, ppCur, cursor)
+	}
+
+	return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
+}
+
+func cursorCloseCallback(ctx context.Context, mod api.Module, pCur uint32) uint32 {
+	err := vtabDelHandle(ctx, mod, pCur)
+	return vtabError(ctx, mod, 0, _VTAB_ERROR, err)
+}
+
+func cursorFilterCallback(ctx context.Context, mod api.Module, pCur uint32, idxNum int32, idxStr, nArg, pArg uint32) uint32 {
+	cursor := vtabGetHandle(ctx, mod, pCur).(VTabCursor)
+	db := ctx.Value(connKey{}).(*Conn)
+	args := make([]Value, nArg)
+	callbackArgs(db, args, pArg)
+	var idxName string
+	if idxStr != 0 {
+		idxName = util.ReadString(mod, idxStr, _MAX_LENGTH)
+	}
+	err := cursor.Filter(int(idxNum), idxName, args...)
+	return vtabError(ctx, mod, pCur, _CURSOR_ERROR, err)
+}
+
+func cursorEOFCallback(ctx context.Context, mod api.Module, pCur uint32) uint32 {
+	cursor := vtabGetHandle(ctx, mod, pCur).(VTabCursor)
+	if cursor.EOF() {
+		return 1
+	}
+	return 0
+}
+
+func cursorNextCallback(ctx context.Context, mod api.Module, pCur uint32) uint32 {
+	cursor := vtabGetHandle(ctx, mod, pCur).(VTabCursor)
+	err := cursor.Next()
+	return vtabError(ctx, mod, pCur, _CURSOR_ERROR, err)
+}
+
+func cursorColumnCallback(ctx context.Context, mod api.Module, pCur, pCtx uint32, n int32) uint32 {
+	cursor := vtabGetHandle(ctx, mod, pCur).(VTabCursor)
+	db := ctx.Value(connKey{}).(*Conn)
+	err := cursor.Column(&Context{db, pCtx}, int(n))
+	return vtabError(ctx, mod, pCur, _CURSOR_ERROR, err)
+}
+
+func cursorRowIDCallback(ctx context.Context, mod api.Module, pCur, pRowID uint32) uint32 {
+	cursor := vtabGetHandle(ctx, mod, pCur).(VTabCursor)
+
+	rowID, err := cursor.RowID()
+	if err == nil {
+		util.WriteUint64(mod, pRowID, uint64(rowID))
+	}
+
+	return vtabError(ctx, mod, pCur, _CURSOR_ERROR, err)
+}
+
+const (
+	_PTR_ERROR = iota
+	_VTAB_ERROR
+	_CURSOR_ERROR
+)
+
+func vtabError(ctx context.Context, mod api.Module, ptr, kind uint32, err error) uint32 {
+	const zErrMsgOffset = 8
+	msg, code := errorCode(err, ERROR)
+	if msg != "" && ptr != 0 {
+		switch kind {
+		case _VTAB_ERROR:
+			ptr = ptr + zErrMsgOffset // zErrMsg
+		case _CURSOR_ERROR:
+			ptr = util.ReadUint32(mod, ptr) + zErrMsgOffset // pVTab->zErrMsg
+		}
+		db := ctx.Value(connKey{}).(*Conn)
+		if ptr := util.ReadUint32(mod, ptr); ptr != 0 {
+			db.free(ptr)
+		}
+		util.WriteUint32(mod, ptr, db.newString(msg))
+	}
+	return code
+}
+
+func vtabGetHandle(ctx context.Context, mod api.Module, ptr uint32) any {
+	const handleOffset = 4
+	handle := util.ReadUint32(mod, ptr-handleOffset)
+	return util.GetHandle(ctx, handle)
+}
+
+func vtabDelHandle(ctx context.Context, mod api.Module, ptr uint32) error {
+	const handleOffset = 4
+	handle := util.ReadUint32(mod, ptr-handleOffset)
+	return util.DelHandle(ctx, handle)
+}
+
+func vtabPutHandle(ctx context.Context, mod api.Module, pptr uint32, val any) {
+	const handleOffset = 4
+	handle := util.AddHandle(ctx, val)
+	ptr := util.ReadUint32(mod, pptr)
+	util.WriteUint32(mod, ptr-handleOffset, handle)
+}

vendor/github.com/ncruces/julianday/julianday.go

@@ -47,7 +47,7 @@ func Float(t time.Time) float64 {
 	return float64(day) + float64(nsec)/nsec_per_day
 }
 
-// Float returns the Julian date for t as a string.
+// Format returns the Julian date for t as a string.
 //
 // This has nanosecond precision.
 func Format(t time.Time) string {
@@ -87,7 +87,7 @@ func FloatTime(date float64) time.Time {
 	return Time(int64(day), int64(nsec))
 }
 
-// Parse parses a formatted Julian date and returns the time value it represents.
+// Parse parses a formatted Julian date and returns the UTC Time it represents.
 //
 // This has nanosecond precision.
 func Parse(s string) (time.Time, error) {

vendor/github.com/stretchr/testify/assert/assertion_compare.go

@@ -28,6 +28,8 @@ var (
 	uint32Type = reflect.TypeOf(uint32(1))
 	uint64Type = reflect.TypeOf(uint64(1))
 
+	uintptrType = reflect.TypeOf(uintptr(1))
+
 	float32Type = reflect.TypeOf(float32(1))
 	float64Type = reflect.TypeOf(float64(1))
 
@@ -308,11 +310,11 @@ func compare(obj1, obj2 interface{}, kind reflect.Kind) (CompareType, bool) {
 	case reflect.Struct:
 		{
 			// All structs enter here. We're not interested in most types.
-			if !canConvert(obj1Value, timeType) {
+			if !obj1Value.CanConvert(timeType) {
 				break
 			}
 
-			// time.Time can compared!
+			// time.Time can be compared!
 			timeObj1, ok := obj1.(time.Time)
 			if !ok {
 				timeObj1 = obj1Value.Convert(timeType).Interface().(time.Time)
@@ -328,7 +330,7 @@ func compare(obj1, obj2 interface{}, kind reflect.Kind) (CompareType, bool) {
 	case reflect.Slice:
 		{
 			// We only care about the []byte type.
-			if !canConvert(obj1Value, bytesType) {
+			if !obj1Value.CanConvert(bytesType) {
 				break
 			}
 
@@ -345,6 +347,26 @@ func compare(obj1, obj2 interface{}, kind reflect.Kind) (CompareType, bool) {
 
 			return CompareType(bytes.Compare(bytesObj1, bytesObj2)), true
 		}
+	case reflect.Uintptr:
+		{
+			uintptrObj1, ok := obj1.(uintptr)
+			if !ok {
+				uintptrObj1 = obj1Value.Convert(uintptrType).Interface().(uintptr)
+			}
+			uintptrObj2, ok := obj2.(uintptr)
+			if !ok {
+				uintptrObj2 = obj2Value.Convert(uintptrType).Interface().(uintptr)
+			}
+			if uintptrObj1 > uintptrObj2 {
+				return compareGreater, true
+			}
+			if uintptrObj1 == uintptrObj2 {
+				return compareEqual, true
+			}
+			if uintptrObj1 < uintptrObj2 {
+				return compareLess, true
+			}
+		}
 	}
 
 	return compareEqual, false

vendor/github.com/stretchr/testify/assert/assertion_compare_can_convert.go

@@ -1,16 +0,0 @@
-//go:build go1.17
-// +build go1.17
-
-// TODO: once support for Go 1.16 is dropped, this file can be
-//       merged/removed with assertion_compare_go1.17_test.go and
-//       assertion_compare_legacy.go
-
-package assert
-
-import "reflect"
-
-// Wrapper around reflect.Value.CanConvert, for compatibility
-// reasons.
-func canConvert(value reflect.Value, to reflect.Type) bool {
-	return value.CanConvert(to)
-}

vendor/github.com/stretchr/testify/assert/assertion_compare_legacy.go

@@ -1,16 +0,0 @@
-//go:build !go1.17
-// +build !go1.17
-
-// TODO: once support for Go 1.16 is dropped, this file can be
-//       merged/removed with assertion_compare_go1.17_test.go and
-//       assertion_compare_can_convert.go
-
-package assert
-
-import "reflect"
-
-// Older versions of Go does not have the reflect.Value.CanConvert
-// method.
-func canConvert(value reflect.Value, to reflect.Type) bool {
-	return false
-}

vendor/github.com/stretchr/testify/assert/assertion_format.go

@@ -1,7 +1,4 @@
-/*
-* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen
-* THIS FILE MUST NOT BE EDITED BY HAND
- */
+// Code generated with github.com/stretchr/testify/_codegen; DO NOT EDIT.
 
 package assert
 
@@ -107,7 +104,7 @@ func EqualExportedValuesf(t TestingT, expected interface{}, actual interface{},
 	return EqualExportedValues(t, expected, actual, append([]interface{}{msg}, args...)...)
 }
 
-// EqualValuesf asserts that two objects are equal or convertable to the same types
+// EqualValuesf asserts that two objects are equal or convertible to the same types
 // and equal.
 //
 //	assert.EqualValuesf(t, uint32(123), int32(123), "error message %s", "formatted")
@@ -616,6 +613,16 @@ func NotErrorIsf(t TestingT, err error, target error, msg string, args ...interf
 	return NotErrorIs(t, err, target, append([]interface{}{msg}, args...)...)
 }
 
+// NotImplementsf asserts that an object does not implement the specified interface.
+//
+//	assert.NotImplementsf(t, (*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
+func NotImplementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotImplements(t, interfaceObject, object, append([]interface{}{msg}, args...)...)
+}
+
 // NotNilf asserts that the specified object is not nil.
 //
 //	assert.NotNilf(t, err, "error message %s", "formatted")
@@ -660,10 +667,12 @@ func NotSamef(t TestingT, expected interface{}, actual interface{}, msg string,
 	return NotSame(t, expected, actual, append([]interface{}{msg}, args...)...)
 }
 
-// NotSubsetf asserts that the specified list(array, slice...) contains not all
-// elements given in the specified subset(array, slice...).
+// NotSubsetf asserts that the specified list(array, slice...) or map does NOT
+// contain all elements given in the specified subset list(array, slice...) or
+// map.
 //
-//	assert.NotSubsetf(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted")
+//	assert.NotSubsetf(t, [1, 3, 4], [1, 2], "error message %s", "formatted")
+//	assert.NotSubsetf(t, {"x": 1, "y": 2}, {"z": 3}, "error message %s", "formatted")
 func NotSubsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@@ -747,10 +756,11 @@ func Samef(t TestingT, expected interface{}, actual interface{}, msg string, arg
 	return Same(t, expected, actual, append([]interface{}{msg}, args...)...)
 }
 
-// Subsetf asserts that the specified list(array, slice...) contains all
-// elements given in the specified subset(array, slice...).
+// Subsetf asserts that the specified list(array, slice...) or map contains all
+// elements given in the specified subset list(array, slice...) or map.
 //
-//	assert.Subsetf(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted")
+//	assert.Subsetf(t, [1, 2, 3], [1, 2], "error message %s", "formatted")
+//	assert.Subsetf(t, {"x": 1, "y": 2}, {"x": 1}, "error message %s", "formatted")
 func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()

vendor/github.com/stretchr/testify/assert/assertion_forward.go

@@ -1,7 +1,4 @@
-/*
-* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen
-* THIS FILE MUST NOT BE EDITED BY HAND
- */
+// Code generated with github.com/stretchr/testify/_codegen; DO NOT EDIT.
 
 package assert
 
@@ -189,7 +186,7 @@ func (a *Assertions) EqualExportedValuesf(expected interface{}, actual interface
 	return EqualExportedValuesf(a.t, expected, actual, msg, args...)
 }
 
-// EqualValues asserts that two objects are equal or convertable to the same types
+// EqualValues asserts that two objects are equal or convertible to the same types
 // and equal.
 //
 //	a.EqualValues(uint32(123), int32(123))
@@ -200,7 +197,7 @@ func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAn
 	return EqualValues(a.t, expected, actual, msgAndArgs...)
 }
 
-// EqualValuesf asserts that two objects are equal or convertable to the same types
+// EqualValuesf asserts that two objects are equal or convertible to the same types
 // and equal.
 //
 //	a.EqualValuesf(uint32(123), int32(123), "error message %s", "formatted")
@@ -1221,6 +1218,26 @@ func (a *Assertions) NotErrorIsf(err error, target error, msg string, args ...in
 	return NotErrorIsf(a.t, err, target, msg, args...)
 }
 
+// NotImplements asserts that an object does not implement the specified interface.
+//
+//	a.NotImplements((*MyInterface)(nil), new(MyObject))
+func (a *Assertions) NotImplements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotImplements(a.t, interfaceObject, object, msgAndArgs...)
+}
+
+// NotImplementsf asserts that an object does not implement the specified interface.
+//
+//	a.NotImplementsf((*MyInterface)(nil), new(MyObject), "error message %s", "formatted")
+func (a *Assertions) NotImplementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool {
+	if h, ok := a.t.(tHelper); ok {
+		h.Helper()
+	}
+	return NotImplementsf(a.t, interfaceObject, object, msg, args...)
+}
+
 // NotNil asserts that the specified object is not nil.
 //
 //	a.NotNil(err)
@@ -1309,10 +1326,12 @@ func (a *Assertions) NotSamef(expected interface{}, actual interface{}, msg stri
 	return NotSamef(a.t, expected, actual, msg, args...)
 }
 
-// NotSubset asserts that the specified list(array, slice...) contains not all
-// elements given in the specified subset(array, slice...).
+// NotSubset asserts that the specified list(array, slice...) or map does NOT
+// contain all elements given in the specified subset list(array, slice...) or
+// map.
 //
-//	a.NotSubset([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]")
+//	a.NotSubset([1, 3, 4], [1, 2])
+//	a.NotSubset({"x": 1, "y": 2}, {"z": 3})
 func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@@ -1320,10 +1339,12 @@ func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs
 	return NotSubset(a.t, list, subset, msgAndArgs...)
 }
 
-// NotSubsetf asserts that the specified list(array, slice...) contains not all
-// elements given in the specified subset(array, slice...).
+// NotSubsetf asserts that the specified list(array, slice...) or map does NOT
+// contain all elements given in the specified subset list(array, slice...) or
+// map.
 //
-//	a.NotSubsetf([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted")
+//	a.NotSubsetf([1, 3, 4], [1, 2], "error message %s", "formatted")
+//	a.NotSubsetf({"x": 1, "y": 2}, {"z": 3}, "error message %s", "formatted")
 func (a *Assertions) NotSubsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@@ -1483,10 +1504,11 @@ func (a *Assertions) Samef(expected interface{}, actual interface{}, msg string,
 	return Samef(a.t, expected, actual, msg, args...)
 }
 
-// Subset asserts that the specified list(array, slice...) contains all
-// elements given in the specified subset(array, slice...).
+// Subset asserts that the specified list(array, slice...) or map contains all
+// elements given in the specified subset list(array, slice...) or map.
 //
-//	a.Subset([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]")
+//	a.Subset([1, 2, 3], [1, 2])
+//	a.Subset({"x": 1, "y": 2}, {"x": 1})
 func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@@ -1494,10 +1516,11 @@ func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...
 	return Subset(a.t, list, subset, msgAndArgs...)
 }
 
-// Subsetf asserts that the specified list(array, slice...) contains all
-// elements given in the specified subset(array, slice...).
+// Subsetf asserts that the specified list(array, slice...) or map contains all
+// elements given in the specified subset list(array, slice...) or map.
 //
-//	a.Subsetf([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted")
+//	a.Subsetf([1, 2, 3], [1, 2], "error message %s", "formatted")
+//	a.Subsetf({"x": 1, "y": 2}, {"x": 1}, "error message %s", "formatted")
 func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()

vendor/github.com/stretchr/testify/assert/assertions.go

@@ -19,7 +19,7 @@ import (
 
 	"github.com/davecgh/go-spew/spew"
 	"github.com/pmezard/go-difflib/difflib"
-	yaml "gopkg.in/yaml.v3"
+	"gopkg.in/yaml.v3"
 )
 
 //go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=assert -template=assertion_format.go.tmpl"
@@ -110,7 +110,12 @@ func copyExportedFields(expected interface{}) interface{} {
 		return result.Interface()
 
 	case reflect.Array, reflect.Slice:
-		result := reflect.MakeSlice(expectedType, expectedValue.Len(), expectedValue.Len())
+		var result reflect.Value
+		if expectedKind == reflect.Array {
+			result = reflect.New(reflect.ArrayOf(expectedValue.Len(), expectedType.Elem())).Elem()
+		} else {
+			result = reflect.MakeSlice(expectedType, expectedValue.Len(), expectedValue.Len())
+		}
 		for i := 0; i < expectedValue.Len(); i++ {
 			index := expectedValue.Index(i)
 			if isNil(index) {
@@ -140,6 +145,8 @@ func copyExportedFields(expected interface{}) interface{} {
 // structures.
 //
 // This function does no assertion of any kind.
+//
+// Deprecated: Use [EqualExportedValues] instead.
 func ObjectsExportedFieldsAreEqual(expected, actual interface{}) bool {
 	expectedCleaned := copyExportedFields(expected)
 	actualCleaned := copyExportedFields(actual)
@@ -153,17 +160,40 @@ func ObjectsAreEqualValues(expected, actual interface{}) bool {
 		return true
 	}
 
-	actualType := reflect.TypeOf(actual)
-	if actualType == nil {
+	expectedValue := reflect.ValueOf(expected)
+	actualValue := reflect.ValueOf(actual)
+	if !expectedValue.IsValid() || !actualValue.IsValid() {
 		return false
 	}
-	expectedValue := reflect.ValueOf(expected)
-	if expectedValue.IsValid() && expectedValue.Type().ConvertibleTo(actualType) {
-		// Attempt comparison after type conversion
-		return reflect.DeepEqual(expectedValue.Convert(actualType).Interface(), actual)
+
+	expectedType := expectedValue.Type()
+	actualType := actualValue.Type()
+	if !expectedType.ConvertibleTo(actualType) {
+		return false
 	}
 
-	return false
+	if !isNumericType(expectedType) || !isNumericType(actualType) {
+		// Attempt comparison after type conversion
+		return reflect.DeepEqual(
+			expectedValue.Convert(actualType).Interface(), actual,
+		)
+	}
+
+	// If BOTH values are numeric, there are chances of false positives due
+	// to overflow or underflow. So, we need to make sure to always convert
+	// the smaller type to a larger type before comparing.
+	if expectedType.Size() >= actualType.Size() {
+		return actualValue.Convert(expectedType).Interface() == expected
+	}
+
+	return expectedValue.Convert(actualType).Interface() == actual
+}
+
+// isNumericType returns true if the type is one of:
+// int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64,
+// float32, float64, complex64, complex128
+func isNumericType(t reflect.Type) bool {
+	return t.Kind() >= reflect.Int && t.Kind() <= reflect.Complex128
 }
 
 /* CallerInfo is necessary because the assert functions use the testing object
@@ -266,7 +296,7 @@ func messageFromMsgAndArgs(msgAndArgs ...interface{}) string {
 
 // Aligns the provided message so that all lines after the first line start at the same location as the first line.
 // Assumes that the first line starts at the correct location (after carriage return, tab, label, spacer and tab).
-// The longestLabelLen parameter specifies the length of the longest label in the output (required becaues this is the
+// The longestLabelLen parameter specifies the length of the longest label in the output (required because this is the
 // basis on which the alignment occurs).
 func indentMessageLines(message string, longestLabelLen int) string {
 	outBuf := new(bytes.Buffer)
@@ -382,6 +412,25 @@ func Implements(t TestingT, interfaceObject interface{}, object interface{}, msg
 	return true
 }
 
+// NotImplements asserts that an object does not implement the specified interface.
+//
+//	assert.NotImplements(t, (*MyInterface)(nil), new(MyObject))
+func NotImplements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
+	interfaceType := reflect.TypeOf(interfaceObject).Elem()
+
+	if object == nil {
+		return Fail(t, fmt.Sprintf("Cannot check if nil does not implement %v", interfaceType), msgAndArgs...)
+	}
+	if reflect.TypeOf(object).Implements(interfaceType) {
+		return Fail(t, fmt.Sprintf("%T implements %v", object, interfaceType), msgAndArgs...)
+	}
+
+	return true
+}
+
 // IsType asserts that the specified objects are of the same type.
 func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
@@ -496,7 +545,7 @@ func samePointers(first, second interface{}) bool {
 // representations appropriate to be presented to the user.
 //
 // If the values are not of like type, the returned strings will be prefixed
-// with the type name, and the value will be enclosed in parenthesis similar
+// with the type name, and the value will be enclosed in parentheses similar
 // to a type conversion in the Go grammar.
 func formatUnequalValues(expected, actual interface{}) (e string, a string) {
 	if reflect.TypeOf(expected) != reflect.TypeOf(actual) {
@@ -523,7 +572,7 @@ func truncatingFormat(data interface{}) string {
 	return value
 }
 
-// EqualValues asserts that two objects are equal or convertable to the same types
+// EqualValues asserts that two objects are equal or convertible to the same types
 // and equal.
 //
 //	assert.EqualValues(t, uint32(123), int32(123))
@@ -566,12 +615,19 @@ func EqualExportedValues(t TestingT, expected, actual interface{}, msgAndArgs ..
 		return Fail(t, fmt.Sprintf("Types expected to match exactly\n\t%v != %v", aType, bType), msgAndArgs...)
 	}
 
+	if aType.Kind() == reflect.Ptr {
+		aType = aType.Elem()
+	}
+	if bType.Kind() == reflect.Ptr {
+		bType = bType.Elem()
+	}
+
 	if aType.Kind() != reflect.Struct {
-		return Fail(t, fmt.Sprintf("Types expected to both be struct \n\t%v != %v", aType.Kind(), reflect.Struct), msgAndArgs...)
+		return Fail(t, fmt.Sprintf("Types expected to both be struct or pointer to struct \n\t%v != %v", aType.Kind(), reflect.Struct), msgAndArgs...)
 	}
 
 	if bType.Kind() != reflect.Struct {
-		return Fail(t, fmt.Sprintf("Types expected to both be struct \n\t%v != %v", bType.Kind(), reflect.Struct), msgAndArgs...)
+		return Fail(t, fmt.Sprintf("Types expected to both be struct or pointer to struct \n\t%v != %v", bType.Kind(), reflect.Struct), msgAndArgs...)
 	}
 
 	expected = copyExportedFields(expected)
@@ -620,17 +676,6 @@ func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
 	return Fail(t, "Expected value not to be nil.", msgAndArgs...)
 }
 
-// containsKind checks if a specified kind in the slice of kinds.
-func containsKind(kinds []reflect.Kind, kind reflect.Kind) bool {
-	for i := 0; i < len(kinds); i++ {
-		if kind == kinds[i] {
-			return true
-		}
-	}
-
-	return false
-}
-
 // isNil checks if a specified object is nil or not, without Failing.
 func isNil(object interface{}) bool {
 	if object == nil {
@@ -638,16 +683,13 @@ func isNil(object interface{}) bool {
 	}
 
 	value := reflect.ValueOf(object)
-	kind := value.Kind()
-	isNilableKind := containsKind(
-		[]reflect.Kind{
-			reflect.Chan, reflect.Func,
-			reflect.Interface, reflect.Map,
-			reflect.Ptr, reflect.Slice, reflect.UnsafePointer},
-		kind)
+	switch value.Kind() {
+	case
+		reflect.Chan, reflect.Func,
+		reflect.Interface, reflect.Map,
+		reflect.Ptr, reflect.Slice, reflect.UnsafePointer:
 
-	if isNilableKind && value.IsNil() {
-		return true
+		return value.IsNil()
 	}
 
 	return false
@@ -731,16 +773,14 @@ func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
 
 }
 
-// getLen try to get length of object.
-// return (false, 0) if impossible.
-func getLen(x interface{}) (ok bool, length int) {
+// getLen tries to get the length of an object.
+// It returns (0, false) if impossible.
+func getLen(x interface{}) (length int, ok bool) {
 	v := reflect.ValueOf(x)
 	defer func() {
-		if e := recover(); e != nil {
-			ok = false
-		}
+		ok = recover() == nil
 	}()
-	return true, v.Len()
+	return v.Len(), true
 }
 
 // Len asserts that the specified object has specific length.
@@ -751,13 +791,13 @@ func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{})
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
 	}
-	ok, l := getLen(object)
+	l, ok := getLen(object)
 	if !ok {
-		return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", object), msgAndArgs...)
+		return Fail(t, fmt.Sprintf("\"%v\" could not be applied builtin len()", object), msgAndArgs...)
 	}
 
 	if l != length {
-		return Fail(t, fmt.Sprintf("\"%s\" should have %d item(s), but has %d", object, length, l), msgAndArgs...)
+		return Fail(t, fmt.Sprintf("\"%v\" should have %d item(s), but has %d", object, length, l), msgAndArgs...)
 	}
 	return true
 }
@@ -919,10 +959,11 @@ func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{})
 
 }
 
-// Subset asserts that the specified list(array, slice...) contains all
-// elements given in the specified subset(array, slice...).
+// Subset asserts that the specified list(array, slice...) or map contains all
+// elements given in the specified subset list(array, slice...) or map.
 //
-//	assert.Subset(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]")
+//	assert.Subset(t, [1, 2, 3], [1, 2])
+//	assert.Subset(t, {"x": 1, "y": 2}, {"x": 1})
 func Subset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@@ -975,10 +1016,12 @@ func Subset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok
 	return true
 }
 
-// NotSubset asserts that the specified list(array, slice...) contains not all
-// elements given in the specified subset(array, slice...).
+// NotSubset asserts that the specified list(array, slice...) or map does NOT
+// contain all elements given in the specified subset list(array, slice...) or
+// map.
 //
-//	assert.NotSubset(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]")
+//	assert.NotSubset(t, [1, 3, 4], [1, 2])
+//	assert.NotSubset(t, {"x": 1, "y": 2}, {"z": 3})
 func NotSubset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@@ -1439,7 +1482,7 @@ func InEpsilon(t TestingT, expected, actual interface{}, epsilon float64, msgAnd
 		h.Helper()
 	}
 	if math.IsNaN(epsilon) {
-		return Fail(t, "epsilon must not be NaN")
+		return Fail(t, "epsilon must not be NaN", msgAndArgs...)
 	}
 	actualEpsilon, err := calcRelativeError(expected, actual)
 	if err != nil {
@@ -1458,19 +1501,26 @@ func InEpsilonSlice(t TestingT, expected, actual interface{}, epsilon float64, m
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
 	}
-	if expected == nil || actual == nil ||
-		reflect.TypeOf(actual).Kind() != reflect.Slice ||
-		reflect.TypeOf(expected).Kind() != reflect.Slice {
+
+	if expected == nil || actual == nil {
 		return Fail(t, "Parameters must be slice", msgAndArgs...)
 	}
 
-	actualSlice := reflect.ValueOf(actual)
 	expectedSlice := reflect.ValueOf(expected)
+	actualSlice := reflect.ValueOf(actual)
 
-	for i := 0; i < actualSlice.Len(); i++ {
-		result := InEpsilon(t, actualSlice.Index(i).Interface(), expectedSlice.Index(i).Interface(), epsilon)
-		if !result {
-			return result
+	if expectedSlice.Type().Kind() != reflect.Slice {
+		return Fail(t, "Expected value must be slice", msgAndArgs...)
+	}
+
+	expectedLen := expectedSlice.Len()
+	if !IsType(t, expected, actual) || !Len(t, actual, expectedLen) {
+		return false
+	}
+
+	for i := 0; i < expectedLen; i++ {
+		if !InEpsilon(t, expectedSlice.Index(i).Interface(), actualSlice.Index(i).Interface(), epsilon, "at index %d", i) {
+			return false
 		}
 	}
 
@@ -1870,23 +1920,18 @@ func (c *CollectT) Errorf(format string, args ...interface{}) {
 }
 
 // FailNow panics.
-func (c *CollectT) FailNow() {
+func (*CollectT) FailNow() {
 	panic("Assertion failed")
 }
 
-// Reset clears the collected errors.
-func (c *CollectT) Reset() {
-	c.errors = nil
+// Deprecated: That was a method for internal usage that should not have been published. Now just panics.
+func (*CollectT) Reset() {
+	panic("Reset() is deprecated")
 }
 
-// Copy copies the collected errors to the supplied t.
-func (c *CollectT) Copy(t TestingT) {
-	if tt, ok := t.(tHelper); ok {
-		tt.Helper()
-	}
-	for _, err := range c.errors {
-		t.Errorf("%v", err)
-	}
+// Deprecated: That was a method for internal usage that should not have been published. Now just panics.
+func (*CollectT) Copy(TestingT) {
+	panic("Copy() is deprecated")
 }
 
 // EventuallyWithT asserts that given condition will be met in waitFor time,
@@ -1912,8 +1957,8 @@ func EventuallyWithT(t TestingT, condition func(collect *CollectT), waitFor time
 		h.Helper()
 	}
 
-	collect := new(CollectT)
-	ch := make(chan bool, 1)
+	var lastFinishedTickErrs []error
+	ch := make(chan []error, 1)
 
 	timer := time.NewTimer(waitFor)
 	defer timer.Stop()
@@ -1924,19 +1969,25 @@ func EventuallyWithT(t TestingT, condition func(collect *CollectT), waitFor time
 	for tick := ticker.C; ; {
 		select {
 		case <-timer.C:
-			collect.Copy(t)
+			for _, err := range lastFinishedTickErrs {
+				t.Errorf("%v", err)
+			}
 			return Fail(t, "Condition never satisfied", msgAndArgs...)
 		case <-tick:
 			tick = nil
-			collect.Reset()
 			go func() {
+				collect := new(CollectT)
+				defer func() {
+					ch <- collect.errors
+				}()
 				condition(collect)
-				ch <- len(collect.errors) == 0
 			}()
-		case v := <-ch:
-			if v {
+		case errs := <-ch:
+			if len(errs) == 0 {
 				return true
 			}
+			// Keep the errors from the last ended condition, so that they can be copied to t if timeout is reached.
+			lastFinishedTickErrs = errs
 			tick = ticker.C
 		}
 	}

vendor/github.com/stretchr/testify/assert/http_assertions.go

@@ -12,7 +12,7 @@ import (
 // an error if building a new request fails.
 func httpCode(handler http.HandlerFunc, method, url string, values url.Values) (int, error) {
 	w := httptest.NewRecorder()
-	req, err := http.NewRequest(method, url, nil)
+	req, err := http.NewRequest(method, url, http.NoBody)
 	if err != nil {
 		return -1, err
 	}
@@ -32,12 +32,12 @@ func HTTPSuccess(t TestingT, handler http.HandlerFunc, method, url string, value
 	}
 	code, err := httpCode(handler, method, url, values)
 	if err != nil {
-		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err))
+		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err), msgAndArgs...)
 	}
 
 	isSuccessCode := code >= http.StatusOK && code <= http.StatusPartialContent
 	if !isSuccessCode {
-		Fail(t, fmt.Sprintf("Expected HTTP success status code for %q but received %d", url+"?"+values.Encode(), code))
+		Fail(t, fmt.Sprintf("Expected HTTP success status code for %q but received %d", url+"?"+values.Encode(), code), msgAndArgs...)
 	}
 
 	return isSuccessCode
@@ -54,12 +54,12 @@ func HTTPRedirect(t TestingT, handler http.HandlerFunc, method, url string, valu
 	}
 	code, err := httpCode(handler, method, url, values)
 	if err != nil {
-		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err))
+		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err), msgAndArgs...)
 	}
 
 	isRedirectCode := code >= http.StatusMultipleChoices && code <= http.StatusTemporaryRedirect
 	if !isRedirectCode {
-		Fail(t, fmt.Sprintf("Expected HTTP redirect status code for %q but received %d", url+"?"+values.Encode(), code))
+		Fail(t, fmt.Sprintf("Expected HTTP redirect status code for %q but received %d", url+"?"+values.Encode(), code), msgAndArgs...)
 	}
 
 	return isRedirectCode
@@ -76,12 +76,12 @@ func HTTPError(t TestingT, handler http.HandlerFunc, method, url string, values
 	}
 	code, err := httpCode(handler, method, url, values)
 	if err != nil {
-		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err))
+		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err), msgAndArgs...)
 	}
 
 	isErrorCode := code >= http.StatusBadRequest
 	if !isErrorCode {
-		Fail(t, fmt.Sprintf("Expected HTTP error status code for %q but received %d", url+"?"+values.Encode(), code))
+		Fail(t, fmt.Sprintf("Expected HTTP error status code for %q but received %d", url+"?"+values.Encode(), code), msgAndArgs...)
 	}
 
 	return isErrorCode
@@ -98,12 +98,12 @@ func HTTPStatusCode(t TestingT, handler http.HandlerFunc, method, url string, va
 	}
 	code, err := httpCode(handler, method, url, values)
 	if err != nil {
-		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err))
+		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err), msgAndArgs...)
 	}
 
 	successful := code == statuscode
 	if !successful {
-		Fail(t, fmt.Sprintf("Expected HTTP status code %d for %q but received %d", statuscode, url+"?"+values.Encode(), code))
+		Fail(t, fmt.Sprintf("Expected HTTP status code %d for %q but received %d", statuscode, url+"?"+values.Encode(), code), msgAndArgs...)
 	}
 
 	return successful
@@ -113,7 +113,10 @@ func HTTPStatusCode(t TestingT, handler http.HandlerFunc, method, url string, va
 // empty string if building a new request fails.
 func HTTPBody(handler http.HandlerFunc, method, url string, values url.Values) string {
 	w := httptest.NewRecorder()
-	req, err := http.NewRequest(method, url+"?"+values.Encode(), nil)
+	if len(values) > 0 {
+		url += "?" + values.Encode()
+	}
+	req, err := http.NewRequest(method, url, http.NoBody)
 	if err != nil {
 		return ""
 	}
@@ -135,7 +138,7 @@ func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method, url string,
 
 	contains := strings.Contains(body, fmt.Sprint(str))
 	if !contains {
-		Fail(t, fmt.Sprintf("Expected response body for \"%s\" to contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body))
+		Fail(t, fmt.Sprintf("Expected response body for \"%s\" to contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body), msgAndArgs...)
 	}
 
 	return contains
@@ -155,7 +158,7 @@ func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method, url strin
 
 	contains := strings.Contains(body, fmt.Sprint(str))
 	if contains {
-		Fail(t, fmt.Sprintf("Expected response body for \"%s\" to NOT contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body))
+		Fail(t, fmt.Sprintf("Expected response body for \"%s\" to NOT contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body), msgAndArgs...)
 	}
 
 	return !contains

vendor/modules.txt

@@ -313,7 +313,7 @@ github.com/gen2brain/shm
 # github.com/glebarez/go-sqlite v1.21.2
 ## explicit; go 1.17
 github.com/glebarez/go-sqlite
-# github.com/glebarez/sqlite v1.10.0
+# github.com/glebarez/sqlite v1.11.0
 ## explicit; go 1.18
 github.com/glebarez/sqlite
 # github.com/go-ole/go-ole v1.3.0
@@ -440,7 +440,7 @@ github.com/jackc/puddle/v2/internal/genstack
 ## explicit
 github.com/jcmturner/gofork/encoding/asn1
 github.com/jcmturner/gofork/x/crypto/pbkdf2
-# github.com/jedib0t/go-pretty/v6 v6.5.8
+# github.com/jedib0t/go-pretty/v6 v6.5.9
 ## explicit; go 1.17
 github.com/jedib0t/go-pretty/v6/table
 github.com/jedib0t/go-pretty/v6/text
@@ -541,17 +541,18 @@ github.com/moloch--/asciicast
 # github.com/moloch--/memmod v0.0.0-20230225130813-fd77d905589e
 ## explicit; go 1.17
 github.com/moloch--/memmod
-# github.com/ncruces/go-sqlite3 v0.7.2
-## explicit; go 1.19
+# github.com/ncruces/go-sqlite3 v0.15.0
+## explicit; go 1.21
 github.com/ncruces/go-sqlite3
 github.com/ncruces/go-sqlite3/driver
 github.com/ncruces/go-sqlite3/embed
 github.com/ncruces/go-sqlite3/internal/util
+github.com/ncruces/go-sqlite3/util/osutil
 github.com/ncruces/go-sqlite3/vfs
 # github.com/ncruces/go-strftime v0.1.9
 ## explicit; go 1.17
 github.com/ncruces/go-strftime
-# github.com/ncruces/julianday v0.1.5
+# github.com/ncruces/julianday v1.0.0
 ## explicit; go 1.17
 github.com/ncruces/julianday
 # github.com/pierrec/lz4/v4 v4.1.21
@@ -645,8 +646,8 @@ github.com/spf13/cobra
 # github.com/spf13/pflag v1.0.5
 ## explicit; go 1.12
 github.com/spf13/pflag
-# github.com/stretchr/testify v1.8.4
-## explicit; go 1.20
+# github.com/stretchr/testify v1.9.0
+## explicit; go 1.17
 github.com/stretchr/testify/assert
 # github.com/tailscale/certstore v0.1.1-0.20231202035212-d3fa0460f47e
 ## explicit; go 1.20
@@ -855,7 +856,7 @@ golang.org/x/sys/windows/svc/mgr
 # golang.org/x/term v0.19.0
 ## explicit; go 1.18
 golang.org/x/term
-# golang.org/x/text v0.14.0
+# golang.org/x/text v0.15.0
 ## explicit; go 1.18
 golang.org/x/text/cases
 golang.org/x/text/encoding