Squashed 'backend/go-sqlite3/' content from commit 20826e8

git-subtree-dir: backend/go-sqlite3
git-subtree-split: 20826e87d8f061d0a7266562f43950ee06e2e9c0

_example/custom_driver_name/Makefile

@@ -0,0 +1,12 @@
+TARGET = custom_driver_name
+ifeq ($(OS),Windows_NT)
+TARGET := $(TARGET).exe
+endif
+
+all : $(TARGET)
+
+$(TARGET) : main.go
+	go build -ldflags="-X 'github.com/mattn/go-sqlite3.driverName=my-sqlite3'"
+
+clean :
+	rm -f $(TARGET)

_example/custom_driver_name/main.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"database/sql"
+
+	_ "github.com/mattn/go-sqlite3"
+)
+
+func main() {
+	for _, driver := range sql.Drivers() {
+		println(driver)
+	}
+}

_example/custom_func/main.go

@@ -0,0 +1,133 @@
+package main
+
+import (
+	"database/sql"
+	"fmt"
+	"log"
+	"math"
+	"math/rand"
+
+	sqlite "github.com/mattn/go-sqlite3"
+)
+
+// Computes x^y
+func pow(x, y int64) int64 {
+	return int64(math.Pow(float64(x), float64(y)))
+}
+
+// Computes the bitwise exclusive-or of all its arguments
+func xor(xs ...int64) int64 {
+	var ret int64
+	for _, x := range xs {
+		ret ^= x
+	}
+	return ret
+}
+
+// Returns a random number. It's actually deterministic here because
+// we don't seed the RNG, but it's an example of a non-pure function
+// from SQLite's POV.
+func getrand() int64 {
+	return rand.Int63()
+}
+
+// Computes the standard deviation of a GROUPed BY set of values
+type stddev struct {
+	xs []int64
+	// Running average calculation
+	sum int64
+	n   int64
+}
+
+func newStddev() *stddev { return &stddev{} }
+
+func (s *stddev) Step(x int64) {
+	s.xs = append(s.xs, x)
+	s.sum += x
+	s.n++
+}
+
+func (s *stddev) Done() float64 {
+	mean := float64(s.sum) / float64(s.n)
+	var sqDiff []float64
+	for _, x := range s.xs {
+		sqDiff = append(sqDiff, math.Pow(float64(x)-mean, 2))
+	}
+	var dev float64
+	for _, x := range sqDiff {
+		dev += x
+	}
+	dev /= float64(len(sqDiff))
+	return math.Sqrt(dev)
+}
+
+func main() {
+	sql.Register("sqlite3_custom", &sqlite.SQLiteDriver{
+		ConnectHook: func(conn *sqlite.SQLiteConn) error {
+			if err := conn.RegisterFunc("pow", pow, true); err != nil {
+				return err
+			}
+			if err := conn.RegisterFunc("xor", xor, true); err != nil {
+				return err
+			}
+			if err := conn.RegisterFunc("rand", getrand, false); err != nil {
+				return err
+			}
+			if err := conn.RegisterAggregator("stddev", newStddev, true); err != nil {
+				return err
+			}
+			return nil
+		},
+	})
+
+	db, err := sql.Open("sqlite3_custom", ":memory:")
+	if err != nil {
+		log.Fatal("Failed to open database:", err)
+	}
+	defer db.Close()
+
+	var i int64
+	err = db.QueryRow("SELECT pow(2,3)").Scan(&i)
+	if err != nil {
+		log.Fatal("POW query error:", err)
+	}
+	fmt.Println("pow(2,3) =", i) // 8
+
+	err = db.QueryRow("SELECT xor(1,2,3,4,5,6)").Scan(&i)
+	if err != nil {
+		log.Fatal("XOR query error:", err)
+	}
+	fmt.Println("xor(1,2,3,4,5) =", i) // 7
+
+	err = db.QueryRow("SELECT rand()").Scan(&i)
+	if err != nil {
+		log.Fatal("RAND query error:", err)
+	}
+	fmt.Println("rand() =", i) // pseudorandom
+
+	_, err = db.Exec("create table foo (department integer, profits integer)")
+	if err != nil {
+		log.Fatal("Failed to create table:", err)
+	}
+	_, err = db.Exec("insert into foo values (1, 10), (1, 20), (1, 45), (2, 42), (2, 115)")
+	if err != nil {
+		log.Fatal("Failed to insert records:", err)
+	}
+
+	rows, err := db.Query("select department, stddev(profits) from foo group by department")
+	if err != nil {
+		log.Fatal("STDDEV query error:", err)
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var dept int64
+		var dev float64
+		if err := rows.Scan(&dept, &dev); err != nil {
+			log.Fatal(err)
+		}
+		fmt.Printf("dept=%d stddev=%f\n", dept, dev)
+	}
+	if err := rows.Err(); err != nil {
+		log.Fatal(err)
+	}
+}

_example/fuzz/fuzz_openexec.go

@@ -0,0 +1,30 @@
+package sqlite3_fuzz
+
+import (
+	"bytes"
+	"database/sql"
+	"io/ioutil"
+
+	_ "github.com/mattn/go-sqlite3"
+)
+
+func FuzzOpenExec(data []byte) int {
+	sep := bytes.IndexByte(data, 0)
+	if sep <= 0 {
+		return 0
+	}
+	err := ioutil.WriteFile("/tmp/fuzz.db", data[sep+1:], 0644)
+	if err != nil {
+		return 0
+	}
+	db, err := sql.Open("sqlite3", "/tmp/fuzz.db")
+	if err != nil {
+		return 0
+	}
+	defer db.Close()
+	_, err = db.Exec(string(data[:sep-1]))
+	if err != nil {
+		return 0
+	}
+	return 1
+}

_example/hook/hook.go

@@ -0,0 +1,78 @@
+package main
+
+import (
+	"database/sql"
+	"log"
+	"os"
+
+	"github.com/mattn/go-sqlite3"
+)
+
+func main() {
+	sqlite3conn := []*sqlite3.SQLiteConn{}
+	sql.Register("sqlite3_with_hook_example",
+		&sqlite3.SQLiteDriver{
+			ConnectHook: func(conn *sqlite3.SQLiteConn) error {
+				sqlite3conn = append(sqlite3conn, conn)
+				conn.RegisterUpdateHook(func(op int, db string, table string, rowid int64) {
+					switch op {
+					case sqlite3.SQLITE_INSERT:
+						log.Println("Notified of insert on db", db, "table", table, "rowid", rowid)
+					}
+				})
+				return nil
+			},
+		})
+	os.Remove("./foo.db")
+	os.Remove("./bar.db")
+
+	srcDb, err := sql.Open("sqlite3_with_hook_example", "./foo.db")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer srcDb.Close()
+	srcDb.Ping()
+
+	_, err = srcDb.Exec("create table foo(id int, value text)")
+	if err != nil {
+		log.Fatal(err)
+	}
+	_, err = srcDb.Exec("insert into foo values(1, 'foo')")
+	if err != nil {
+		log.Fatal(err)
+	}
+	_, err = srcDb.Exec("insert into foo values(2, 'bar')")
+	if err != nil {
+		log.Fatal(err)
+	}
+	_, err = srcDb.Query("select * from foo")
+	if err != nil {
+		log.Fatal(err)
+	}
+	destDb, err := sql.Open("sqlite3_with_hook_example", "./bar.db")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer destDb.Close()
+	destDb.Ping()
+
+	bk, err := sqlite3conn[1].Backup("main", sqlite3conn[0], "main")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	_, err = bk.Step(-1)
+	if err != nil {
+		log.Fatal(err)
+	}
+	_, err = destDb.Query("select * from foo")
+	if err != nil {
+		log.Fatal(err)
+	}
+	_, err = destDb.Exec("insert into foo values(3, 'bar')")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	bk.Finish()
+}

_example/json/json.go

@@ -0,0 +1,129 @@
+package main
+
+import (
+	"database/sql"
+	"database/sql/driver"
+	"encoding/json"
+	"fmt"
+	_ "github.com/mattn/go-sqlite3"
+	"log"
+	"os"
+)
+
+type Tag struct {
+	Name    string `json:"name"`
+	Country string `json:"country"`
+}
+
+func (t *Tag) Scan(value interface{}) error {
+	return json.Unmarshal([]byte(value.(string)), t)
+}
+
+func (t *Tag) Value() (driver.Value, error) {
+	b, err := json.Marshal(t)
+	return string(b), err
+}
+
+func main() {
+	os.Remove("./foo.db")
+
+	db, err := sql.Open("sqlite3", "./foo.db")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	// Using a json-typed column
+	// Verify type: `create table foo (tag text) strict`
+	_, err = db.Exec(`create table foo (tag json)`)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	stmt, err := db.Prepare("insert into foo(tag) values(?)")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer stmt.Close()
+	_, err = stmt.Exec(`{"name": "mattn", "country": "japan"}`)
+	if err != nil {
+		log.Fatal(err)
+	}
+	_, err = stmt.Exec(`{"name": "michael", "country": "usa"}`)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	var country string
+	err = db.QueryRow("select tag->>'country' from foo where tag->>'name' = 'mattn'").Scan(&country)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println(country)
+
+	var tag Tag
+	err = db.QueryRow("select tag from foo where tag->>'name' = 'mattn'").Scan(&tag)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	fmt.Println(tag.Name)
+
+	tag.Country = "日本"
+	_, err = db.Exec(`update foo set tag = ? where tag->>'name' == 'mattn'`, &tag)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = db.QueryRow("select tag->>'country' from foo where tag->>'name' = 'mattn'").Scan(&country)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println(country)
+
+	// Using a jsonb-typed column
+	// Verify type: `create table bar (tag blob) strict`
+	_, err = db.Exec(`create table bar (tag jsonb)`)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	stmt, err = db.Prepare("insert into bar(tag) values(jsonb(?))")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer stmt.Close()
+	_, err = stmt.Exec(`{"name": "mattn", "country": "japan"}`)
+	if err != nil {
+		log.Fatal(err)
+	}
+	_, err = stmt.Exec(`{"name": "michael", "country": "usa"}`)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = db.QueryRow("select tag->>'country' from bar where tag->>'name' = 'mattn'").Scan(&country)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println(country)
+
+	err = db.QueryRow("select json(tag) from bar where tag->>'name' = 'mattn'").Scan(&tag)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	fmt.Println(tag.Name)
+
+	tag.Country = "日本"
+	_, err = db.Exec(`update bar set tag = jsonb(?) where tag->>'name' == 'mattn'`, &tag)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = db.QueryRow("select tag->>'country' from bar where tag->>'name' = 'mattn'").Scan(&country)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println(country)
+}

_example/limit/limit.go

@@ -0,0 +1,113 @@
+package main
+
+import (
+	"database/sql"
+	"fmt"
+	"log"
+	"os"
+	"strings"
+
+	"github.com/mattn/go-sqlite3"
+)
+
+func createBulkInsertQuery(n int, start int) (query string, args []any) {
+	values := make([]string, n)
+	args = make([]any, n*2)
+	pos := 0
+	for i := 0; i < n; i++ {
+		values[i] = "(?, ?)"
+		args[pos] = start + i
+		args[pos+1] = fmt.Sprintf("こんにちは世界%03d", i)
+		pos += 2
+	}
+	query = fmt.Sprintf(
+		"insert into foo(id, name) values %s",
+		strings.Join(values, ", "),
+	)
+	return
+}
+
+func bulkInsert(db *sql.DB, query string, args []any) (err error) {
+	stmt, err := db.Prepare(query)
+	if err != nil {
+		return
+	}
+
+	_, err = stmt.Exec(args...)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+func main() {
+	var sqlite3conn *sqlite3.SQLiteConn
+	sql.Register("sqlite3_with_limit", &sqlite3.SQLiteDriver{
+		ConnectHook: func(conn *sqlite3.SQLiteConn) error {
+			sqlite3conn = conn
+			return nil
+		},
+	})
+
+	os.Remove("./foo.db")
+	db, err := sql.Open("sqlite3_with_limit", "./foo.db")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	sqlStmt := `
+	create table foo (id integer not null primary key, name text);
+	delete from foo;
+	`
+	_, err = db.Exec(sqlStmt)
+	if err != nil {
+		log.Printf("%q: %s\n", err, sqlStmt)
+		return
+	}
+
+	if sqlite3conn == nil {
+		log.Fatal("not set sqlite3 connection")
+	}
+
+	limitVariableNumber := sqlite3conn.GetLimit(sqlite3.SQLITE_LIMIT_VARIABLE_NUMBER)
+	log.Printf("default SQLITE_LIMIT_VARIABLE_NUMBER: %d", limitVariableNumber)
+
+	num := 400
+	query, args := createBulkInsertQuery(num, 0)
+	err = bulkInsert(db, query, args)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	smallLimitVariableNumber := 100
+	sqlite3conn.SetLimit(sqlite3.SQLITE_LIMIT_VARIABLE_NUMBER, smallLimitVariableNumber)
+
+	limitVariableNumber = sqlite3conn.GetLimit(sqlite3.SQLITE_LIMIT_VARIABLE_NUMBER)
+	log.Printf("updated SQLITE_LIMIT_VARIABLE_NUMBER: %d", limitVariableNumber)
+
+	query, args = createBulkInsertQuery(num, num)
+	err = bulkInsert(db, query, args)
+	if err != nil {
+		if err != nil {
+			log.Printf("expect failed since SQLITE_LIMIT_VARIABLE_NUMBER is too small: %v", err)
+		}
+	}
+
+	bigLimitVariableNumber := 999999
+	sqlite3conn.SetLimit(sqlite3.SQLITE_LIMIT_VARIABLE_NUMBER, bigLimitVariableNumber)
+	limitVariableNumber = sqlite3conn.GetLimit(sqlite3.SQLITE_LIMIT_VARIABLE_NUMBER)
+	log.Printf("set SQLITE_LIMIT_VARIABLE_NUMBER: %d", bigLimitVariableNumber)
+	log.Printf("updated SQLITE_LIMIT_VARIABLE_NUMBER: %d", limitVariableNumber)
+
+	query, args = createBulkInsertQuery(500, num+num)
+	err = bulkInsert(db, query, args)
+	if err != nil {
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+
+	log.Println("no error if SQLITE_LIMIT_VARIABLE_NUMBER > 999")
+}

_example/mod_regexp/Makefile

@@ -0,0 +1,27 @@
+ifeq ($(OS),Windows_NT)
+EXE=extension.exe
+LIB_EXT=dll
+RM=cmd /c del
+LDFLAG=
+else
+EXE=extension
+ifeq ($(shell uname -s),Darwin)
+LIB_EXT=dylib
+else
+LIB_EXT=so
+endif
+RM=rm -f
+LDFLAG=-fPIC
+endif
+LIB=sqlite3_mod_regexp.$(LIB_EXT)
+
+all : $(EXE) $(LIB)
+
+$(EXE) : extension.go
+	go build $<
+
+$(LIB) : sqlite3_mod_regexp.c
+	gcc $(LDFLAG) -shared -o $@ $< -lsqlite3 -lpcre
+
+clean :
+	@-$(RM) $(EXE) $(LIB)

_example/mod_regexp/extension.go

@@ -0,0 +1,43 @@
+package main
+
+import (
+	"database/sql"
+	"fmt"
+	"github.com/mattn/go-sqlite3"
+	"log"
+)
+
+func main() {
+	sql.Register("sqlite3_with_extensions",
+		&sqlite3.SQLiteDriver{
+			Extensions: []string{
+				"sqlite3_mod_regexp",
+			},
+		})
+
+	db, err := sql.Open("sqlite3_with_extensions", ":memory:")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	// Force db to make a new connection in pool
+	// by putting the original in a transaction
+	tx, err := db.Begin()
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer tx.Commit()
+
+	// New connection works (hopefully!)
+	rows, err := db.Query("select 'hello world' where 'hello world' regexp '^hello.*d$'")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var helloworld string
+		rows.Scan(&helloworld)
+		fmt.Println(helloworld)
+	}
+}

_example/mod_regexp/sqlite3_mod_regexp.c

@@ -0,0 +1,35 @@
+#include <pcre.h>
+#include <string.h>
+#include <stdio.h>
+#include <sqlite3ext.h>
+
+SQLITE_EXTENSION_INIT1
+static void regexp_func(sqlite3_context *context, int argc, sqlite3_value **argv) {
+  if (argc >= 2) {
+    const char *target  = (const char *)sqlite3_value_text(argv[1]);
+    const char *pattern = (const char *)sqlite3_value_text(argv[0]);
+    const char* errstr = NULL;
+    int erroff = 0;
+    int vec[500];
+    int n, rc;
+    pcre* re = pcre_compile(pattern, 0, &errstr, &erroff, NULL);
+    if (!re) {
+      sqlite3_result_error(context, errstr, 0);
+      return;
+    }
+    rc = pcre_exec(re, NULL, target, strlen(target), 0, 0, vec, 500); 
+    if (rc <= 0) {
+      sqlite3_result_int(context, 0);
+      return;
+    }
+    sqlite3_result_int(context, 1);
+  }
+}
+
+#ifdef _WIN32
+__declspec(dllexport)
+#endif
+int sqlite3_extension_init(sqlite3 *db, char **errmsg, const sqlite3_api_routines *api) {
+  SQLITE_EXTENSION_INIT2(api);
+  return sqlite3_create_function(db, "regexp", 2, SQLITE_UTF8, (void*)db, regexp_func, NULL, NULL);
+}

_example/mod_vtable/Makefile

@@ -0,0 +1,29 @@
+ifeq ($(OS),Windows_NT)
+EXE=extension.exe
+LIB_EXT=dll
+RM=cmd /c del
+LIBCURL=-lcurldll
+LDFLAG=
+else
+EXE=extension
+ifeq ($(shell uname -s),Darwin)
+LIB_EXT=dylib
+else
+LIB_EXT=so
+endif
+RM=rm -f
+LDFLAG=-fPIC
+LIBCURL=-lcurl
+endif
+LIB=sqlite3_mod_vtable.$(LIB_EXT)
+
+all : $(EXE) $(LIB)
+
+$(EXE) : extension.go
+	go build $<
+
+$(LIB) : sqlite3_mod_vtable.cc
+	g++ $(LDFLAG) -shared -o $@ $< -lsqlite3 $(LIBCURL)
+
+clean :
+	@-$(RM) $(EXE) $(LIB)

_example/mod_vtable/extension.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"database/sql"
+	"fmt"
+	"log"
+
+	"github.com/mattn/go-sqlite3"
+)
+
+func main() {
+	sql.Register("sqlite3_with_extensions",
+		&sqlite3.SQLiteDriver{
+			Extensions: []string{
+				"sqlite3_mod_vtable",
+			},
+		})
+
+	db, err := sql.Open("sqlite3_with_extensions", ":memory:")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	db.Exec("create virtual table repo using github(id, full_name, description, html_url)")
+
+	rows, err := db.Query("select id, full_name, description, html_url from repo")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var id, fullName, description, htmlURL string
+		rows.Scan(&id, &fullName, &description, &htmlURL)
+		fmt.Printf("%s: %s\n\t%s\n\t%s\n\n", id, fullName, description, htmlURL)
+	}
+}

_example/mod_vtable/sqlite3_mod_vtable.cc

@@ -0,0 +1,238 @@
+#include <string>
+#include <sstream>
+#include <sqlite3.h>
+#include <sqlite3ext.h>
+#include <curl/curl.h>
+#include "picojson.h"
+
+#ifdef _WIN32
+# define EXPORT __declspec(dllexport)
+#else
+# define EXPORT
+#endif
+
+SQLITE_EXTENSION_INIT1;
+
+typedef struct {
+  char* data;   // response data from server
+  size_t size;  // response size of data
+} MEMFILE;
+
+MEMFILE*
+memfopen() {
+  MEMFILE* mf = (MEMFILE*) malloc(sizeof(MEMFILE));
+  if (mf) {
+    mf->data = NULL;
+    mf->size = 0;
+  }
+  return mf;
+}
+
+void
+memfclose(MEMFILE* mf) {
+  if (mf->data) free(mf->data);
+  free(mf);
+}
+
+size_t
+memfwrite(char* ptr, size_t size, size_t nmemb, void* stream) {
+  MEMFILE* mf = (MEMFILE*) stream;
+  int block = size * nmemb;
+  if (!mf) return block; // through
+  if (!mf->data)
+    mf->data = (char*) malloc(block);
+  else
+    mf->data = (char*) realloc(mf->data, mf->size + block);
+  if (mf->data) {
+    memcpy(mf->data + mf->size, ptr, block);
+    mf->size += block;
+  }
+  return block;
+}
+
+char*
+memfstrdup(MEMFILE* mf) {
+  char* buf;
+  if (mf->size == 0) return NULL;
+  buf = (char*) malloc(mf->size + 1);
+  memcpy(buf, mf->data, mf->size);
+  buf[mf->size] = 0;
+  return buf;
+}
+
+static int
+my_connect(sqlite3 *db, void *pAux, int argc, const char * const *argv, sqlite3_vtab **ppVTab, char **c) {
+  std::stringstream ss;
+  ss << "CREATE TABLE " << argv[0]
+    << "(id int, full_name text, description text, html_url text)";
+  int rc = sqlite3_declare_vtab(db, ss.str().c_str());
+  *ppVTab = (sqlite3_vtab *) sqlite3_malloc(sizeof(sqlite3_vtab));
+  memset(*ppVTab, 0, sizeof(sqlite3_vtab));
+  return rc;
+}
+
+static int
+my_create(sqlite3 *db, void *pAux, int argc, const char * const * argv, sqlite3_vtab **ppVTab, char **c) {
+  return my_connect(db, pAux, argc, argv, ppVTab, c);
+}
+
+static int my_disconnect(sqlite3_vtab *pVTab) {
+  sqlite3_free(pVTab);
+  return SQLITE_OK;
+}
+
+static int
+my_destroy(sqlite3_vtab *pVTab) {
+  sqlite3_free(pVTab);
+  return SQLITE_OK;
+}
+
+typedef struct {
+  sqlite3_vtab_cursor base;
+  int index;
+  picojson::value* rows;
+} cursor;
+
+static int
+my_open(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor) {
+  MEMFILE* mf;
+  CURL* curl;
+  char* json;
+  CURLcode res = CURLE_OK;
+  char error[CURL_ERROR_SIZE] = {0};
+  char* cert_file = getenv("SSL_CERT_FILE");
+
+  mf = memfopen();
+  curl = curl_easy_init();
+  curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1);
+  curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 2);
+  curl_easy_setopt(curl, CURLOPT_USERAGENT, "curl/7.29.0");
+  curl_easy_setopt(curl, CURLOPT_URL, "https://api.github.com/repositories");
+  if (cert_file)
+    curl_easy_setopt(curl, CURLOPT_CAINFO, cert_file);
+  curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
+  curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, error);
+  curl_easy_setopt(curl, CURLOPT_WRITEDATA, mf);
+  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, memfwrite);
+  res = curl_easy_perform(curl);
+  curl_easy_cleanup(curl);
+  if (res != CURLE_OK) {
+    std::cerr << error << std::endl;
+    return SQLITE_FAIL;
+  }
+
+  picojson::value* v = new picojson::value;
+  std::string err;
+  picojson::parse(*v, mf->data, mf->data + mf->size, &err);
+  memfclose(mf);
+
+  if (!err.empty()) {
+    delete v;
+    std::cerr << err << std::endl;
+    return SQLITE_FAIL;
+  }
+
+  cursor *c = (cursor *)sqlite3_malloc(sizeof(cursor));
+  c->rows = v;
+  c->index = 0;
+  *ppCursor = &c->base;
+  return SQLITE_OK;
+}
+
+static int
+my_close(cursor *c) {
+  delete c->rows;
+  sqlite3_free(c);
+  return SQLITE_OK;
+}
+
+static int
+my_filter(cursor *c, int idxNum, const char *idxStr, int argc, sqlite3_value **argv) {
+  c->index = 0;
+  return SQLITE_OK;
+}
+
+static int
+my_next(cursor *c) {
+  c->index++;
+  return SQLITE_OK;
+}
+
+static int
+my_eof(cursor *c) {
+  return c->index >= c->rows->get<picojson::array>().size() ? 1 : 0;
+}
+
+static int
+my_column(cursor *c, sqlite3_context *ctxt, int i) {
+  picojson::value v = c->rows->get<picojson::array>()[c->index];
+  picojson::object row = v.get<picojson::object>();
+  const char* p = NULL;
+  switch (i) {
+  case 0:
+    p = row["id"].to_str().c_str();
+    break;
+  case 1:
+    p = row["full_name"].to_str().c_str();
+    break;
+  case 2:
+    p = row["description"].to_str().c_str();
+    break;
+  case 3:
+    p = row["html_url"].to_str().c_str();
+    break;
+  }
+  sqlite3_result_text(ctxt, strdup(p), strlen(p), free);
+  return SQLITE_OK;
+}
+
+static int
+my_rowid(cursor *c, sqlite3_int64 *pRowid) {
+  *pRowid = c->index;
+  return SQLITE_OK;
+}
+
+static int
+my_bestindex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo) {
+  return SQLITE_OK;
+}
+
+static const sqlite3_module module = {
+  0,
+  my_create,
+  my_connect,
+  my_bestindex,
+  my_disconnect,
+  my_destroy,
+  my_open,
+  (int (*)(sqlite3_vtab_cursor *)) my_close,
+  (int (*)(sqlite3_vtab_cursor *, int, char const *, int, sqlite3_value **)) my_filter,
+  (int (*)(sqlite3_vtab_cursor *)) my_next,
+  (int (*)(sqlite3_vtab_cursor *)) my_eof,
+  (int (*)(sqlite3_vtab_cursor *, sqlite3_context *, int)) my_column,
+  (int (*)(sqlite3_vtab_cursor *, sqlite3_int64 *)) my_rowid,
+  NULL, // my_update
+  NULL, // my_begin
+  NULL, // my_sync
+  NULL, // my_commit
+  NULL, // my_rollback
+  NULL, // my_findfunction
+  NULL, // my_rename
+};
+
+static void
+destructor(void *arg) {
+  return;
+}
+
+
+extern "C" {
+
+EXPORT int
+sqlite3_extension_init(sqlite3 *db, char **errmsg, const sqlite3_api_routines *api) {
+  SQLITE_EXTENSION_INIT2(api);
+  sqlite3_create_module_v2(db, "github", &module, NULL, destructor);
+  return 0;
+}
+
+}

_example/simple/Dockerfile

@@ -0,0 +1,47 @@
+# =============================================================================
+#  Multi-stage Dockerfile Example
+# =============================================================================
+#  This is a simple Dockerfile that will build an image of scratch-base image.
+#  Usage:
+#    docker build -t simple:local . && docker run --rm simple:local
+# =============================================================================
+
+# -----------------------------------------------------------------------------
+#  Build Stage
+# -----------------------------------------------------------------------------
+FROM golang:alpine3.18 AS build
+
+# Important:
+#   Because this is a CGO enabled package, you are required to set it as 1.
+ENV CGO_ENABLED=1
+
+RUN apk add --no-cache \
+    # Important: required for go-sqlite3
+    gcc \
+    # Required for Alpine
+    musl-dev
+
+WORKDIR /workspace
+
+COPY . /workspace/
+
+RUN \
+    cd _example/simple && \
+    go mod init github.com/mattn/sample && \
+    go mod edit -replace=github.com/mattn/go-sqlite3=../.. && \
+    go mod tidy && \
+    go install -ldflags='-s -w -extldflags "-static"' ./simple.go
+
+RUN \
+    # Smoke test
+    set -o pipefail; \
+    /go/bin/simple | grep 99\ こんにちは世界099
+
+# -----------------------------------------------------------------------------
+#  Main Stage
+# -----------------------------------------------------------------------------
+FROM scratch
+
+COPY --from=build /go/bin/simple /usr/local/bin/simple
+
+ENTRYPOINT [ "/usr/local/bin/simple" ]

_example/simple/simple.go

@@ -0,0 +1,109 @@
+package main
+
+import (
+	"database/sql"
+	"fmt"
+	_ "github.com/mattn/go-sqlite3"
+	"log"
+	"os"
+)
+
+func main() {
+	os.Remove("./foo.db")
+
+	db, err := sql.Open("sqlite3", "./foo.db")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	sqlStmt := `
+	create table foo (id integer not null primary key, name text);
+	delete from foo;
+	`
+	_, err = db.Exec(sqlStmt)
+	if err != nil {
+		log.Printf("%q: %s\n", err, sqlStmt)
+		return
+	}
+
+	tx, err := db.Begin()
+	if err != nil {
+		log.Fatal(err)
+	}
+	stmt, err := tx.Prepare("insert into foo(id, name) values(?, ?)")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer stmt.Close()
+	for i := 0; i < 100; i++ {
+		_, err = stmt.Exec(i, fmt.Sprintf("こんにちは世界%03d", i))
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+	err = tx.Commit()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	rows, err := db.Query("select id, name from foo")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var id int
+		var name string
+		err = rows.Scan(&id, &name)
+		if err != nil {
+			log.Fatal(err)
+		}
+		fmt.Println(id, name)
+	}
+	err = rows.Err()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	stmt, err = db.Prepare("select name from foo where id = ?")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer stmt.Close()
+	var name string
+	err = stmt.QueryRow("3").Scan(&name)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println(name)
+
+	_, err = db.Exec("delete from foo")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	_, err = db.Exec("insert into foo(id, name) values(1, 'foo'), (2, 'bar'), (3, 'baz')")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	rows, err = db.Query("select id, name from foo")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var id int
+		var name string
+		err = rows.Scan(&id, &name)
+		if err != nil {
+			log.Fatal(err)
+		}
+		fmt.Println(id, name)
+	}
+	err = rows.Err()
+	if err != nil {
+		log.Fatal(err)
+	}
+}

_example/trace/main.go

@@ -0,0 +1,264 @@
+package main
+
+import (
+	"database/sql"
+	"fmt"
+	"log"
+	"os"
+
+	sqlite3 "github.com/mattn/go-sqlite3"
+)
+
+func traceCallback(info sqlite3.TraceInfo) int {
+	// Not very readable but may be useful; uncomment next line in case of doubt:
+	//fmt.Printf("Trace: %#v\n", info)
+
+	var dbErrText string
+	if info.DBError.Code != 0 || info.DBError.ExtendedCode != 0 {
+		dbErrText = fmt.Sprintf("; DB error: %#v", info.DBError)
+	} else {
+		dbErrText = "."
+	}
+
+	// Show the Statement-or-Trigger text in curly braces ('{', '}')
+	// since from the *paired* ASCII characters they are
+	// the least used in SQL syntax, therefore better visual delimiters.
+	// Maybe show 'ExpandedSQL' the same way as 'StmtOrTrigger'.
+	//
+	// A known use of curly braces (outside strings) is
+	// for ODBC escape sequences. Not likely to appear here.
+	//
+	// Template languages, etc. don't matter, we should see their *result*
+	// at *this* level.
+	// Strange curly braces in SQL code that reached the database driver
+	// suggest that there is a bug in the application.
+	// The braces are likely to be either template syntax or
+	// a programming language's string interpolation syntax.
+
+	var expandedText string
+	if info.ExpandedSQL != "" {
+		if info.ExpandedSQL == info.StmtOrTrigger {
+			expandedText = " = exp"
+		} else {
+			expandedText = fmt.Sprintf(" expanded {%q}", info.ExpandedSQL)
+		}
+	} else {
+		expandedText = ""
+	}
+
+	// SQLite docs as of September 6, 2016: Tracing and Profiling Functions
+	// https://www.sqlite.org/c3ref/profile.html
+	//
+	// The profile callback time is in units of nanoseconds, however
+	// the current implementation is only capable of millisecond resolution
+	// so the six least significant digits in the time are meaningless.
+	// Future versions of SQLite might provide greater resolution on the profiler callback.
+
+	var runTimeText string
+	if info.RunTimeNanosec == 0 {
+		if info.EventCode == sqlite3.TraceProfile {
+			//runTimeText = "; no time" // seems confusing
+			runTimeText = "; time 0" // no measurement unit
+		} else {
+			//runTimeText = "; no time" // seems useless and confusing
+		}
+	} else {
+		const nanosPerMillisec = 1000000
+		if info.RunTimeNanosec%nanosPerMillisec == 0 {
+			runTimeText = fmt.Sprintf("; time %d ms", info.RunTimeNanosec/nanosPerMillisec)
+		} else {
+			// unexpected: better than millisecond resolution
+			runTimeText = fmt.Sprintf("; time %d ns!!!", info.RunTimeNanosec)
+		}
+	}
+
+	var modeText string
+	if info.AutoCommit {
+		modeText = "-AC-"
+	} else {
+		modeText = "+Tx+"
+	}
+
+	fmt.Printf("Trace: ev %d %s conn 0x%x, stmt 0x%x {%q}%s%s%s\n",
+		info.EventCode, modeText, info.ConnHandle, info.StmtHandle,
+		info.StmtOrTrigger, expandedText,
+		runTimeText,
+		dbErrText)
+	return 0
+}
+
+func main() {
+	eventMask := sqlite3.TraceStmt | sqlite3.TraceProfile | sqlite3.TraceRow | sqlite3.TraceClose
+
+	sql.Register("sqlite3_tracing",
+		&sqlite3.SQLiteDriver{
+			ConnectHook: func(conn *sqlite3.SQLiteConn) error {
+				err := conn.SetTrace(&sqlite3.TraceConfig{
+					Callback:        traceCallback,
+					EventMask:       eventMask,
+					WantExpandedSQL: true,
+				})
+				return err
+			},
+		})
+
+	os.Exit(dbMain())
+}
+
+// Harder to do DB work in main().
+// It's better with a separate function because
+// 'defer' and 'os.Exit' don't go well together.
+//
+// DO NOT use 'log.Fatal...' below: remember that it's equivalent to
+// Print() followed by a call to os.Exit(1) --- and
+// we want to avoid Exit() so 'defer' can do cleanup.
+// Use 'log.Panic...' instead.
+
+func dbMain() int {
+	db, err := sql.Open("sqlite3_tracing", ":memory:")
+	if err != nil {
+		fmt.Printf("Failed to open database: %#+v\n", err)
+		return 1
+	}
+	defer db.Close()
+
+	err = db.Ping()
+	if err != nil {
+		log.Panic(err)
+	}
+
+	dbSetup(db)
+
+	dbDoInsert(db)
+	dbDoInsertPrepared(db)
+	dbDoSelect(db)
+	dbDoSelectPrepared(db)
+
+	return 0
+}
+
+// 'DDL' stands for "Data Definition Language":
+
+// Note: "INTEGER PRIMARY KEY NOT NULL AUTOINCREMENT" causes the error
+// 'near "AUTOINCREMENT": syntax error'; without "NOT NULL" it works.
+const tableDDL = `CREATE TABLE t1 (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ note VARCHAR NOT NULL
+)`
+
+// 'DML' stands for "Data Manipulation Language":
+
+const insertDML = "INSERT INTO t1 (note) VALUES (?)"
+const selectDML = "SELECT id, note FROM t1 WHERE note LIKE ?"
+
+const textPrefix = "bla-1234567890-"
+const noteTextPattern = "%Prep%"
+
+const nGenRows = 4 // Number of Rows to Generate (for *each* approach tested)
+
+func dbSetup(db *sql.DB) {
+	var err error
+
+	_, err = db.Exec("DROP TABLE IF EXISTS t1")
+	if err != nil {
+		log.Panic(err)
+	}
+	_, err = db.Exec(tableDDL)
+	if err != nil {
+		log.Panic(err)
+	}
+}
+
+func dbDoInsert(db *sql.DB) {
+	const Descr = "DB-Exec"
+	for i := 0; i < nGenRows; i++ {
+		result, err := db.Exec(insertDML, textPrefix+Descr)
+		if err != nil {
+			log.Panic(err)
+		}
+
+		resultDoCheck(result, Descr, i)
+	}
+}
+
+func dbDoInsertPrepared(db *sql.DB) {
+	const Descr = "DB-Prepare"
+
+	stmt, err := db.Prepare(insertDML)
+	if err != nil {
+		log.Panic(err)
+	}
+	defer stmt.Close()
+
+	for i := 0; i < nGenRows; i++ {
+		result, err := stmt.Exec(textPrefix + Descr)
+		if err != nil {
+			log.Panic(err)
+		}
+
+		resultDoCheck(result, Descr, i)
+	}
+}
+
+func resultDoCheck(result sql.Result, callerDescr string, callIndex int) {
+	lastID, err := result.LastInsertId()
+	if err != nil {
+		log.Panic(err)
+	}
+	nAffected, err := result.RowsAffected()
+	if err != nil {
+		log.Panic(err)
+	}
+
+	log.Printf("Exec result for %s (%d): ID = %d, affected = %d\n", callerDescr, callIndex, lastID, nAffected)
+}
+
+func dbDoSelect(db *sql.DB) {
+	const Descr = "DB-Query"
+
+	rows, err := db.Query(selectDML, noteTextPattern)
+	if err != nil {
+		log.Panic(err)
+	}
+	defer rows.Close()
+
+	rowsDoFetch(rows, Descr)
+}
+
+func dbDoSelectPrepared(db *sql.DB) {
+	const Descr = "DB-Prepare"
+
+	stmt, err := db.Prepare(selectDML)
+	if err != nil {
+		log.Panic(err)
+	}
+	defer stmt.Close()
+
+	rows, err := stmt.Query(noteTextPattern)
+	if err != nil {
+		log.Panic(err)
+	}
+	defer rows.Close()
+
+	rowsDoFetch(rows, Descr)
+}
+
+func rowsDoFetch(rows *sql.Rows, callerDescr string) {
+	var nRows int
+	var id int64
+	var note string
+
+	for rows.Next() {
+		err := rows.Scan(&id, &note)
+		if err != nil {
+			log.Panic(err)
+		}
+		log.Printf("Row for %s (%d): id=%d, note=%q\n",
+			callerDescr, nRows, id, note)
+		nRows++
+	}
+	if err := rows.Err(); err != nil {
+		log.Panic(err)
+	}
+	log.Printf("Total %d rows for %s.\n", nRows, callerDescr)
+}

_example/vtable/main.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"database/sql"
+	"fmt"
+	"log"
+
+	"github.com/mattn/go-sqlite3"
+)
+
+func main() {
+	sql.Register("sqlite3_with_extensions", &sqlite3.SQLiteDriver{
+		ConnectHook: func(conn *sqlite3.SQLiteConn) error {
+			return conn.CreateModule("github", &githubModule{})
+		},
+	})
+	db, err := sql.Open("sqlite3_with_extensions", ":memory:")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	_, err = db.Exec("create virtual table repo using github(id, full_name, description, html_url)")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	rows, err := db.Query("select id, full_name, description, html_url from repo")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var id, fullName, description, htmlURL string
+		rows.Scan(&id, &fullName, &description, &htmlURL)
+		fmt.Printf("%s: %s\n\t%s\n\t%s\n\n", id, fullName, description, htmlURL)
+	}
+}

_example/vtable/vtable.go

@@ -0,0 +1,116 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/mattn/go-sqlite3"
+)
+
+type githubRepo struct {
+	ID          int    `json:"id"`
+	FullName    string `json:"full_name"`
+	Description string `json:"description"`
+	HTMLURL     string `json:"html_url"`
+}
+
+type githubModule struct {
+}
+
+func (m *githubModule) Create(c *sqlite3.SQLiteConn, args []string) (sqlite3.VTab, error) {
+	err := c.DeclareVTab(fmt.Sprintf(`
+		CREATE TABLE %s (
+			id INT,
+			full_name TEXT,
+			description TEXT,
+			html_url TEXT
+		)`, args[0]))
+	if err != nil {
+		return nil, err
+	}
+	return &ghRepoTable{}, nil
+}
+
+func (m *githubModule) Connect(c *sqlite3.SQLiteConn, args []string) (sqlite3.VTab, error) {
+	return m.Create(c, args)
+}
+
+func (m *githubModule) DestroyModule() {}
+
+type ghRepoTable struct {
+	repos []githubRepo
+}
+
+func (v *ghRepoTable) Open() (sqlite3.VTabCursor, error) {
+	resp, err := http.Get("https://api.github.com/repositories")
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	var repos []githubRepo
+	if err := json.Unmarshal(body, &repos); err != nil {
+		return nil, err
+	}
+	return &ghRepoCursor{0, repos}, nil
+}
+
+func (v *ghRepoTable) BestIndex(csts []sqlite3.InfoConstraint, ob []sqlite3.InfoOrderBy) (*sqlite3.IndexResult, error) {
+	used := make([]bool, len(csts))
+	return &sqlite3.IndexResult{
+		IdxNum: 0,
+		IdxStr: "default",
+		Used:   used,
+	}, nil
+}
+
+func (v *ghRepoTable) Disconnect() error { return nil }
+func (v *ghRepoTable) Destroy() error    { return nil }
+
+type ghRepoCursor struct {
+	index int
+	repos []githubRepo
+}
+
+func (vc *ghRepoCursor) Column(c *sqlite3.SQLiteContext, col int) error {
+	switch col {
+	case 0:
+		c.ResultInt(vc.repos[vc.index].ID)
+	case 1:
+		c.ResultText(vc.repos[vc.index].FullName)
+	case 2:
+		c.ResultText(vc.repos[vc.index].Description)
+	case 3:
+		c.ResultText(vc.repos[vc.index].HTMLURL)
+	}
+	return nil
+}
+
+func (vc *ghRepoCursor) Filter(idxNum int, idxStr string, vals []any) error {
+	vc.index = 0
+	return nil
+}
+
+func (vc *ghRepoCursor) Next() error {
+	vc.index++
+	return nil
+}
+
+func (vc *ghRepoCursor) EOF() bool {
+	return vc.index >= len(vc.repos)
+}
+
+func (vc *ghRepoCursor) Rowid() (int64, error) {
+	return int64(vc.index), nil
+}
+
+func (vc *ghRepoCursor) Close() error {
+	return nil
+}

_example/vtable_eponymous_only/main.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"database/sql"
+	"fmt"
+	"log"
+
+	"github.com/mattn/go-sqlite3"
+)
+
+func main() {
+	sql.Register("sqlite3_with_extensions", &sqlite3.SQLiteDriver{
+		ConnectHook: func(conn *sqlite3.SQLiteConn) error {
+			return conn.CreateModule("series", &seriesModule{})
+		},
+	})
+	db, err := sql.Open("sqlite3_with_extensions", ":memory:")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	rows, err := db.Query("select * from series")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var value int
+		rows.Scan(&value)
+		fmt.Printf("value: %d\n", value)
+	}
+}

_example/vtable_eponymous_only/vtable.go

@@ -0,0 +1,118 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/mattn/go-sqlite3"
+)
+
+type seriesModule struct{}
+
+func (m *seriesModule) EponymousOnlyModule() {}
+
+func (m *seriesModule) Create(c *sqlite3.SQLiteConn, args []string) (sqlite3.VTab, error) {
+	err := c.DeclareVTab(fmt.Sprintf(`
+		CREATE TABLE %s (
+			value INT,
+			start HIDDEN,
+			stop HIDDEN,
+			step HIDDEN
+		)`, args[0]))
+	if err != nil {
+		return nil, err
+	}
+	return &seriesTable{0, 0, 1}, nil
+}
+
+func (m *seriesModule) Connect(c *sqlite3.SQLiteConn, args []string) (sqlite3.VTab, error) {
+	return m.Create(c, args)
+}
+
+func (m *seriesModule) DestroyModule() {}
+
+type seriesTable struct {
+	start int64
+	stop  int64
+	step  int64
+}
+
+func (v *seriesTable) Open() (sqlite3.VTabCursor, error) {
+	return &seriesCursor{v, 0}, nil
+}
+
+func (v *seriesTable) BestIndex(csts []sqlite3.InfoConstraint, ob []sqlite3.InfoOrderBy) (*sqlite3.IndexResult, error) {
+	used := make([]bool, len(csts))
+	for c, cst := range csts {
+		if cst.Usable && cst.Op == sqlite3.OpEQ {
+			used[c] = true
+		}
+	}
+
+	return &sqlite3.IndexResult{
+		IdxNum: 0,
+		IdxStr: "default",
+		Used:   used,
+	}, nil
+}
+
+func (v *seriesTable) Disconnect() error { return nil }
+func (v *seriesTable) Destroy() error    { return nil }
+
+type seriesCursor struct {
+	*seriesTable
+	value int64
+}
+
+func (vc *seriesCursor) Column(c *sqlite3.SQLiteContext, col int) error {
+	switch col {
+	case 0:
+		c.ResultInt64(vc.value)
+	case 1:
+		c.ResultInt64(vc.seriesTable.start)
+	case 2:
+		c.ResultInt64(vc.seriesTable.stop)
+	case 3:
+		c.ResultInt64(vc.seriesTable.step)
+	}
+	return nil
+}
+
+func (vc *seriesCursor) Filter(idxNum int, idxStr string, vals []any) error {
+	switch {
+	case len(vals) < 1:
+		vc.seriesTable.start = 0
+		vc.seriesTable.stop = 1000
+		vc.value = vc.seriesTable.start
+	case len(vals) < 2:
+		vc.seriesTable.start = vals[0].(int64)
+		vc.seriesTable.stop = 1000
+		vc.value = vc.seriesTable.start
+	case len(vals) < 3:
+		vc.seriesTable.start = vals[0].(int64)
+		vc.seriesTable.stop = vals[1].(int64)
+		vc.value = vc.seriesTable.start
+	case len(vals) < 4:
+		vc.seriesTable.start = vals[0].(int64)
+		vc.seriesTable.stop = vals[1].(int64)
+		vc.seriesTable.step = vals[2].(int64)
+	}
+
+	return nil
+}
+
+func (vc *seriesCursor) Next() error {
+	vc.value += vc.step
+	return nil
+}
+
+func (vc *seriesCursor) EOF() bool {
+	return vc.value > vc.stop
+}
+
+func (vc *seriesCursor) Rowid() (int64, error) {
+	return int64(vc.value), nil
+}
+
+func (vc *seriesCursor) Close() error {
+	return nil
+}