package sqlmem
import (
"context"
"database/sql"
"database/sql/driver"
"path/filepath"
"testing"
sqldriver "github.com/ncruces/go-sqlite3/driver"
)
// trunkLean is the wrapper before panic recovery: it only answers
// IsValid. It is the baseline the guarded one is measured against.
type trunkLean struct {
conn
limit int64
}
func (l trunkLean) IsValid() bool {
n, ok := Committed(l.Raw())
return !ok || n <= l.limit
}
type trunkConnector struct{ driver.Connector }
func (c trunkConnector) Connect(ctx context.Context) (driver.Conn, error) {
dc, err := c.Connector.Connect(ctx)
if err != nil {
return nil, err
}
return trunkLean{dc.(conn), 32 << 20}, nil
}
func benchDB(b *testing.B, kind string) *sql.DB {
b.Helper()
dsn := "file:" + filepath.Join(b.TempDir(), "b.db")
c, err := (&sqldriver.SQLite{}).OpenConnector(dsn)
if err != nil {
b.Fatal(err)
}
var db *sql.DB
limit := int64(32 << 20)
switch kind {
case "raw":
db = sql.OpenDB(c)
case "trunk":
db = sql.OpenDB(trunkConnector{c})
default:
db = sql.OpenDB(Connector{Inner: c, Limit: &limit})
}
db.SetMaxOpenConns(1)
b.Cleanup(func() { db.Close() })
return db
}
func BenchmarkQuery(b *testing.B) {
for _, kind := range []string{"raw", "trunk", "guarded"} {
b.Run("one-row/"+kind, func(b *testing.B) {
db := benchDB(b, kind)
b.ReportAllocs()
for b.Loop() {
var n int
if err := db.QueryRow(`SELECT ?`, 1).Scan(&n); err != nil {
b.Fatal(err)
}
}
})
b.Run("scan-1000/"+kind, func(b *testing.B) {
db := benchDB(b, kind)
b.ReportAllocs()
for b.Loop() {
rows, err := db.Query(`WITH RECURSIVE s(i) AS (SELECT 1 UNION ALL SELECT i+1 FROM s WHERE i < 1000) SELECT i FROM s`)
if err != nil {
b.Fatal(err)
}
for rows.Next() {
var n int
if err := rows.Scan(&n); err != nil {
b.Fatal(err)
}
}
if err := rows.Close(); err != nil {
b.Fatal(err)
}
}
})
}
}