add Bob and SQLR benchmarks

README.md

@@ -2,13 +2,14 @@
 
 [![Go Reference](https://pkg.go.dev/badge/github.com/efectn/go-orm-benchmarks.svg)](https://pkg.go.dev/github.com/efectn/go-orm-benchmarks)
 
-Advanced benchmarks for +10 Go ORMs. Originally forked from [orm-benchmark](https://github.com/frederikhors/orm-benchmark).
+Advanced benchmarks for Go ORMs and database libraries. Originally forked from [orm-benchmark](https://github.com/frederikhors/orm-benchmark).
 
 ### ORMs
 
 All package run in no-cache mode.
 
 - [beego/orm](https://github.com/astaxie/beego/tree/master/orm)
+- [bob](https://github.com/stephenafamo/bob)
 - [bun](https://github.com/uptrace/bun)
 - [gorm 2](https://github.com/go-gorm/gorm)
 - [pg](https://github.com/go-pg/pg)
@@ -22,7 +23,9 @@ All package run in no-cache mode.
 - [pop](https://github.com/gobuffalo/pop)
 - [rel](https://github.com/go-rel/rel)
 - [reform](https://github.com/go-reform/reform)
-- [sqlboiler](https://github.com/volatiletech/sqlboiler)
+- [sqlboiler](https://github.com/aarondl/sqlboiler)
+- [sqlr](https://github.com/gandaldf/sqlr)
+- [sqlrgen](https://github.com/gandaldf/sqlr/tree/main/cmd/sqlrgen)
 - [sqlx](https://github.com/jmoiron/sqlx)
 - [pgx](https://github.com/jackc/pgx)
 - [zorm](https://gitee.com/chunanyong/zorm)
@@ -48,6 +51,23 @@ go-orm-benchmarks -orm=bun
 
 **_Note: Also, you can run `./run_benchmarks.sh` and you can get output like results.md format._**
 
+### Benchmark contract
+
+The tables are created once and truncated before every calibration run. Each
+iteration performs one logical operation; bulk operations process exactly 100
+rows. Setup and validation are excluded from the measured interval. Reads must
+materialize exactly one or 100 rows, while persisted row counts and counter
+sentinels are checked centrally after each run. Central validation treats
+primary-key values as opaque and never asserts a specific ID; adapters use the
+key returned by their native setup path.
+
+Insert benchmarks do not explicitly request a returned row unless the library's
+normal insert API intrinsically returns or populates a key. Update benchmarks do
+not reload the updated row. For bulk inserts, each adapter uses its idiomatic
+bulk API: `pgx`, `pgx_pool`, and `sqlc` intentionally use PostgreSQL `COPY`,
+while adapters whose bulk API emits `INSERT ... VALUES` retain that strategy.
+This difference is considered part of the library abstraction being measured.
+
 ### Results
 Look at [`results.md`](results.md) to see detailed benchmark results.
 

bench/beego.go

@@ -38,35 +38,28 @@ func (beego *Beego) Close() error {
 
 func (beego *Beego) Insert(b *testing.B) {
 	m := NewModel()
-
-	b.ReportAllocs()
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
+	helper.BenchExec(b, beego.Name(), "Insert", func() error {
 		m.Id = 0
-
 		_, err := beego.conn.Insert(m)
 		if err != nil {
-			helper.SetError(b, beego.Name(), "Insert", fmt.Sprintf("beego: insert: %v", err))
+			return fmt.Errorf("beego: insert: %w", err)
 		}
-	}
+		return nil
+	})
 }
 
 func (beego *Beego) InsertMulti(b *testing.B) {
-	ms := make([]*Model, 0, 100)
-	for i := 0; i < 100; i++ {
+	ms := make([]*Model, 0, helper.BatchSize)
+	for i := 0; i < helper.BatchSize; i++ {
 		ms = append(ms, NewModel())
 	}
-
-	b.ReportAllocs()
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		_, err := beego.conn.InsertMulti(100, ms)
-		if err != nil {
-			helper.SetError(b, beego.Name(), "InsertMulti", err.Error())
+	helper.BenchExec(b, beego.Name(), "InsertMulti", func() error {
+		for _, m := range ms {
+			m.Id = 0
 		}
-	}
+		_, err := beego.conn.InsertMulti(helper.BatchSize, ms)
+		return err
+	})
 }
 
 func (beego *Beego) Update(b *testing.B) {
@@ -75,17 +68,14 @@ func (beego *Beego) Update(b *testing.B) {
 	_, err := beego.conn.Insert(m)
 	if err != nil {
 		helper.SetError(b, beego.Name(), "Update", err.Error())
+		return
 	}
+	m.Counter = helper.UpdatedCounter
 
-	b.ReportAllocs()
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
+	helper.BenchExec(b, beego.Name(), "Update", func() error {
 		_, err := beego.conn.Update(m)
-		if err != nil {
-			helper.SetError(b, beego.Name(), "Update", err.Error())
-		}
-	}
+		return err
+	})
 }
 
 func (beego *Beego) Read(b *testing.B) {
@@ -94,37 +84,31 @@ func (beego *Beego) Read(b *testing.B) {
 	_, err := beego.conn.Insert(m)
 	if err != nil {
 		helper.SetError(b, beego.Name(), "Read", err.Error())
+		return
 	}
 
-	b.ReportAllocs()
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		err := beego.conn.Read(m)
-		if err != nil {
-			helper.SetError(b, beego.Name(), "Read", err.Error())
+	helper.BenchRows(b, beego.Name(), "Read", 1, func() (int, error) {
+		if err := beego.conn.Read(m); err != nil {
+			return 0, err
 		}
-	}
+		return 1, nil
+	})
 }
 
 func (beego *Beego) ReadSlice(b *testing.B) {
 	m := NewModel()
-	for i := 0; i < 100; i++ {
+	for i := 0; i < helper.BatchSize; i++ {
 		m.Id = 0
 		_, err := beego.conn.Insert(m)
 		if err != nil {
 			helper.SetError(b, beego.Name(), "ReadSlice", err.Error())
+			return
 		}
 	}
 
-	b.ReportAllocs()
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
+	helper.BenchRows(b, beego.Name(), "ReadSlice", helper.BatchSize, func() (int, error) {
 		var models []*Model
-		_, err := beego.conn.QueryTable("models").Filter("id__gt", 0).Limit(100).All(&models)
-		if err != nil {
-			helper.SetError(b, beego.Name(), "ReadSlice", err.Error())
-		}
-	}
+		_, err := beego.conn.QueryTable("models").Filter("id__gt", 0).Limit(helper.BatchSize).All(&models)
+		return len(models), err
+	})
 }

bench/bob.go

@@ -0,0 +1,120 @@
+package bench
+
+import (
+	"testing"
+
+	"github.com/efectn/go-orm-benchmarks/helper"
+	_ "github.com/jackc/pgx/v5/stdlib"
+	boblib "github.com/stephenafamo/bob"
+	"github.com/stephenafamo/bob/dialect/psql"
+	"github.com/stephenafamo/bob/dialect/psql/sm"
+	"github.com/stephenafamo/bob/dialect/psql/um"
+)
+
+type Bob struct {
+	helper.ORMInterface
+	conn boblib.DB
+}
+
+var _ helper.ORMInterface = (*Bob)(nil)
+
+func CreateBob() helper.ORMInterface {
+	return &Bob{}
+}
+
+func (bob *Bob) Name() string {
+	return "bob"
+}
+
+func (bob *Bob) Init() error {
+	var err error
+	bob.conn, err = boblib.Open("pgx", helper.OrmSource)
+	if err != nil {
+		return err
+	}
+
+	bob.conn.SetMaxOpenConns(helper.OrmMaxConn)
+	bob.conn.SetMaxIdleConns(helper.OrmMaxIdle)
+	return nil
+}
+
+func (bob *Bob) Close() error {
+	return bob.conn.Close()
+}
+
+func (bob *Bob) Insert(b *testing.B) {
+	setter := newBobModelSetter(NewModel())
+	helper.BenchExec(b, bob.Name(), "Insert", func() error {
+		_, err := bobModels.Insert(setter).Exec(ctx, bob.conn)
+		return err
+	})
+}
+
+func (bob *Bob) InsertMulti(b *testing.B) {
+	setters := make([]*bobModelSetter, helper.BatchSize)
+	for i := range setters {
+		setters[i] = newBobModelSetter(NewModel())
+	}
+
+	helper.BenchExec(b, bob.Name(), "InsertMulti", func() error {
+		_, err := bobModels.Insert(boblib.ToMods(setters...)).Exec(ctx, bob.conn)
+		return err
+	})
+}
+
+func (bob *Bob) Update(b *testing.B) {
+	setter := newBobModelSetter(NewModel())
+	model, err := bobModels.Insert(setter).One(ctx, bob.conn)
+	if err != nil {
+		helper.SetError(b, bob.Name(), "Update", err.Error())
+		return
+	}
+	updated := NewModel()
+	updated.Counter = helper.UpdatedCounter
+	setter = newBobModelSetter(updated)
+
+	helper.BenchExec(b, bob.Name(), "Update", func() error {
+		_, err = bobModels.Update(
+			setter.UpdateMod(),
+			um.Where(model.primaryKeyEquals()),
+		).Exec(ctx, bob.conn)
+		return err
+	})
+}
+
+func (bob *Bob) Read(b *testing.B) {
+	model, err := bobModels.Insert(newBobModelSetter(NewModel())).One(ctx, bob.conn)
+	if err != nil {
+		helper.SetError(b, bob.Name(), "Read", err.Error())
+		return
+	}
+
+	helper.BenchRows(b, bob.Name(), "Read", 1, func() (int, error) {
+		_, err = bobModels.Query(
+			sm.Where(psql.Quote("models", "id").EQ(psql.Arg(model.ID))),
+		).One(ctx, bob.conn)
+		if err != nil {
+			return 0, err
+		}
+		return 1, nil
+	})
+}
+
+func (bob *Bob) ReadSlice(b *testing.B) {
+	setter := newBobModelSetter(NewModel())
+	for i := 0; i < helper.BatchSize; i++ {
+		_, err := bobModels.Insert(setter).One(ctx, bob.conn)
+		if err != nil {
+			helper.SetError(b, bob.Name(), "ReadSlice", err.Error())
+			return
+		}
+	}
+
+	helper.BenchRows(b, bob.Name(), "ReadSlice", helper.BatchSize, func() (int, error) {
+		models, err := bobModels.Query(
+			sm.Where(psql.Quote("models", "id").GT(psql.Arg(0))),
+			sm.Limit(helper.BatchSize),
+		).All(ctx, bob.conn)
+		return len(models), err
+	})
+}