Merge upstream

_example/fuzz/fuzz_openexec.go

@@ -22,7 +22,7 @@ func FuzzOpenExec(data []byte) int {
 		return 0
 	}
 	defer db.Close()
-	_, err = db.Exec(string(data[:sep-1]))
+	_, err = db.Exec(string(data[:sep]))
 	if err != nil {
 		return 0
 	}

_example/hook/hook.go

@@ -45,10 +45,11 @@ func main() {
 	if err != nil {
 		log.Fatal(err)
 	}
-	_, err = srcDb.Query("select * from foo")
+	rows, err := srcDb.Query("select * from foo")
 	if err != nil {
 		log.Fatal(err)
 	}
+	rows.Close()
 	destDb, err := sql.Open("sqlite3_with_hook_example", "./bar.db")
 	if err != nil {
 		log.Fatal(err)
@@ -65,14 +66,17 @@ func main() {
 	if err != nil {
 		log.Fatal(err)
 	}
-	_, err = destDb.Query("select * from foo")
+	rows, err = destDb.Query("select * from foo")
 	if err != nil {
 		log.Fatal(err)
 	}
+	rows.Close()
 	_, err = destDb.Exec("insert into foo values(3, 'bar')")
 	if err != nil {
 		log.Fatal(err)
 	}
 
-	bk.Finish()
+	if err := bk.Finish(); err != nil {
+		log.Fatal(err)
+	}
 }

_example/json/json.go

@@ -16,7 +16,17 @@ type Tag struct {
 }
 
 func (t *Tag) Scan(value interface{}) error {
-	return json.Unmarshal([]byte(value.(string)), t)
+	switch v := value.(type) {
+	case nil:
+		*t = Tag{}
+		return nil
+	case string:
+		return json.Unmarshal([]byte(v), t)
+	case []byte:
+		return json.Unmarshal(v, t)
+	default:
+		return fmt.Errorf("unsupported type %T for Tag", value)
+	}
 }
 
 func (t *Tag) Value() (driver.Value, error) {

_example/limit/limit.go

@@ -32,6 +32,7 @@ func bulkInsert(db *sql.DB, query string, args []any) (err error) {
 	if err != nil {
 		return
 	}
+	defer stmt.Close()
 
 	_, err = stmt.Exec(args...)
 	if err != nil {
@@ -89,11 +90,13 @@ func main() {
 
 	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)
-		}
+	if err == nil {
+		log.Fatal("expected failure since SQLITE_LIMIT_VARIABLE_NUMBER is too small, but insert succeeded")
+	}
+	if !strings.Contains(err.Error(), "too many SQL variables") {
+		log.Fatalf("expected too many SQL variables error, got: %v", err)
 	}
+	log.Printf("expect failed since SQLITE_LIMIT_VARIABLE_NUMBER is too small: %v", err)
 
 	bigLimitVariableNumber := 999999
 	sqlite3conn.SetLimit(sqlite3.SQLITE_LIMIT_VARIABLE_NUMBER, bigLimitVariableNumber)
@@ -104,9 +107,7 @@ func main() {
 	query, args = createBulkInsertQuery(500, num+num)
 	err = bulkInsert(db, query, args)
 	if err != nil {
-		if err != nil {
-			log.Fatal(err)
-		}
+		log.Fatal(err)
 	}
 
 	log.Println("no error if SQLITE_LIMIT_VARIABLE_NUMBER > 999")

_example/vtable/vtable.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io/ioutil"
 	"net/http"
+	"strings"
 
 	"github.com/mattn/go-sqlite3"
 )
@@ -20,13 +21,20 @@ type githubModule struct {
 }
 
 func (m *githubModule) Create(c *sqlite3.SQLiteConn, args []string) (sqlite3.VTab, error) {
+	// args holds the raw xCreate arguments: args[0] is the module name,
+	// args[1] the database name, args[2] the virtual table name, and any
+	// user arguments follow.
+	if len(args) < 3 {
+		return nil, fmt.Errorf("githubModule: unexpected arguments: %v", args)
+	}
+	tableName := `"` + strings.ReplaceAll(args[2], `"`, `""`) + `"`
 	err := c.DeclareVTab(fmt.Sprintf(`
 		CREATE TABLE %s (
 			id INT,
 			full_name TEXT,
 			description TEXT,
 			html_url TEXT
-		)`, args[0]))
+		)`, tableName))
 	if err != nil {
 		return nil, err
 	}
@@ -49,6 +57,9 @@ func (v *ghRepoTable) Open() (sqlite3.VTabCursor, error) {
 		return nil, err
 	}
 	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("fetching repositories: %s", resp.Status)
+	}
 
 	body, err := ioutil.ReadAll(resp.Body)
 	if err != nil {

_example/vtable_eponymous_only/main.go

@@ -20,14 +20,26 @@ func main() {
 	}
 	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)
+	for _, query := range []string{
+		"select value from series where value between 3 and 5",
+		"select value from series where start = 10 and stop = 20 and step = 5",
+		"select value from series where start = 3 and stop = -3 and step = -2",
+	} {
+		fmt.Println(query)
+		rows, err := db.Query(query)
+		if err != nil {
+			log.Fatal(err)
+		}
+		for rows.Next() {
+			var value int
+			if err := rows.Scan(&value); err != nil {
+				log.Fatal(err)
+			}
+			fmt.Printf("value: %d\n", value)
+		}
+		if err := rows.Err(); err != nil {
+			log.Fatal(err)
+		}
+		rows.Close()
 	}
 }

_example/vtable_eponymous_only/vtable.go

@@ -1,7 +1,9 @@
 package main
 
 import (
+	"errors"
 	"fmt"
+	"strings"
 
 	"github.com/mattn/go-sqlite3"
 )
@@ -21,7 +23,7 @@ func (m *seriesModule) Create(c *sqlite3.SQLiteConn, args []string) (sqlite3.VTa
 	if err != nil {
 		return nil, err
 	}
-	return &seriesTable{0, 0, 1}, nil
+	return &seriesTable{}, nil
 }
 
 func (m *seriesModule) Connect(c *sqlite3.SQLiteConn, args []string) (sqlite3.VTab, error) {
@@ -30,27 +32,46 @@ func (m *seriesModule) Connect(c *sqlite3.SQLiteConn, args []string) (sqlite3.VT
 
 func (m *seriesModule) DestroyModule() {}
 
-type seriesTable struct {
-	start int64
-	stop  int64
-	step  int64
-}
+type seriesTable struct{}
 
 func (v *seriesTable) Open() (sqlite3.VTabCursor, error) {
-	return &seriesCursor{v, 0}, nil
+	return &seriesCursor{}, nil
 }
 
 func (v *seriesTable) BestIndex(csts []sqlite3.InfoConstraint, ob []sqlite3.InfoOrderBy) (*sqlite3.IndexResult, error) {
+	// Consume equality constraints on the hidden parameter columns
+	// (start, stop, step) only. A constraint on the value column must be
+	// left to SQLite, otherwise it would be dropped from the WHERE clause
+	// and the query would return wrong results.
 	used := make([]bool, len(csts))
+	var params []byte
 	for c, cst := range csts {
-		if cst.Usable && cst.Op == sqlite3.OpEQ {
-			used[c] = true
+		if !cst.Usable || cst.Op != sqlite3.OpEQ {
+			continue
 		}
+		var p byte
+		switch cst.Column {
+		case 1:
+			p = 's' // start
+		case 2:
+			p = 'e' // stop
+		case 3:
+			p = 't' // step
+		default:
+			continue
+		}
+		if strings.IndexByte(string(params), p) >= 0 {
+			continue
+		}
+		used[c] = true
+		params = append(params, p)
 	}
 
+	// IdxStr records which parameter each Filter argument holds, in
+	// argument order.
 	return &sqlite3.IndexResult{
 		IdxNum: 0,
-		IdxStr: "default",
+		IdxStr: string(params),
 		Used:   used,
 	}, nil
 }
@@ -59,7 +80,9 @@ func (v *seriesTable) Disconnect() error { return nil }
 func (v *seriesTable) Destroy() error    { return nil }
 
 type seriesCursor struct {
-	*seriesTable
+	start int64
+	stop  int64
+	step  int64
 	value int64
 }
 
@@ -68,35 +91,38 @@ func (vc *seriesCursor) Column(c *sqlite3.SQLiteContext, col int) error {
 	case 0:
 		c.ResultInt64(vc.value)
 	case 1:
-		c.ResultInt64(vc.seriesTable.start)
+		c.ResultInt64(vc.start)
 	case 2:
-		c.ResultInt64(vc.seriesTable.stop)
+		c.ResultInt64(vc.stop)
 	case 3:
-		c.ResultInt64(vc.seriesTable.step)
+		c.ResultInt64(vc.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)
+	start, stop, step := int64(0), int64(1000), int64(1)
+	for i := 0; i < len(idxStr) && i < len(vals); i++ {
+		n, ok := vals[i].(int64)
+		if !ok {
+			return fmt.Errorf("series: argument %d must be an integer", i+1)
+		}
+		switch idxStr[i] {
+		case 's':
+			start = n
+		case 'e':
+			stop = n
+		case 't':
+			step = n
+		}
 	}
-
+	if step == 0 {
+		return errors.New("series: step must not be zero")
+	}
+	vc.start = start
+	vc.stop = stop
+	vc.step = step
+	vc.value = start
 	return nil
 }
 
@@ -106,6 +132,9 @@ func (vc *seriesCursor) Next() error {
 }
 
 func (vc *seriesCursor) EOF() bool {
+	if vc.step < 0 {
+		return vc.value < vc.stop
+	}
 	return vc.value > vc.stop
 }
 

callback.go

@@ -131,6 +131,27 @@ func lookupHandle(handle unsafe.Pointer) any {
 	return lookupHandleVal(handle).val
 }
 
+// deleteHandle releases a single handle created by newHandle. It is a no-op
+// if the handle is unknown (e.g. already released).
+func deleteHandle(handle unsafe.Pointer) {
+	handleLock.Lock()
+	defer handleLock.Unlock()
+
+	current := loadHandleVals()
+	if _, ok := current[handle]; !ok {
+		return
+	}
+	next := make(map[unsafe.Pointer]handleVal, len(current)-1)
+	for h, v := range current {
+		if h == handle {
+			continue
+		}
+		next[h] = v
+	}
+	handleVals.Store(next)
+	C.free(handle)
+}
+
 func deleteHandles(db *SQLiteConn) {
 	handleLock.Lock()
 	defer handleLock.Unlock()