`IsReadOnlyQuery()` incorrectly returns `false` for COUNT/EXISTS queries

[nb-park]

Encountered trying to prevent a write-then-read scenario.

Code Sample

// query hook, see next comment for test code
db.AddQueryHook(&RoutingHook{})

// works
selectQuery := db.NewSelect().Model(&User{})
fmt.Printf("SELECT: %v\n", bun.IsReadOnlyQuery(selectQuery))

// don't work
// These create internal wrapper types that fail the type assertion
countQuery := db.NewSelect().Model(&User{}).Count(ctx) 
// isReadOnly fails in query hook

existsQuery := db.NewSelect().Model(&User{}).Exists(ctx)
// isReadOnly fails in query hook

edited due to invalid code; see below for working (broken) example

Root Cause

The offending line performs a type check invalid for embedded structs:

sel, ok := query.(*SelectQuery)

Env

Bun version: v1.2.15
Go version: 1.24

Suggestion

Implement an interface to fix this. Starting with an issue because I'm not super familiar with the repo, concerned about side-effects and whether there are other similar patterns which might be broken.

[vmihailenco]

Neither Count(ctx) nor Exists(ctx) return a query so I don't understand what you mean.

[nb-park]

Many apologies. Got carried away and omitted the query hook. Attaching code here. Please note that this includes the workaround. Happy to open a PR at some point.

Run with go mod tidy && go run main.go

module bun-readonly-bug

go 1.24

require (
	github.com/uptrace/bun v1.2.15
	github.com/uptrace/bun/dialect/sqlitedialect v1.2.15
	github.com/uptrace/bun/driver/sqliteshim v1.2.15
)

package main

import (
	"context"
	"database/sql"
	"fmt"
	"log"
	"reflect"

	"github.com/uptrace/bun"
	"github.com/uptrace/bun/dialect/sqlitedialect"
	"github.com/uptrace/bun/driver/sqliteshim"
)

// User represents a basic user model
type User struct {
	bun.BaseModel `bun:"table:users,alias:u"`

	ID   int64  `bun:"id,pk,autoincrement"`
	Name string `bun:"name,notnull"`
}

// RoutingHook implements bun.QueryHook interface
type RoutingHook struct{}

func (h *RoutingHook) isReadOperation(q bun.Query) bool {
	// First try Bun's built-in check
	if bun.IsReadOnlyQuery(q) {
		fmt.Printf("IsReadOnlyQuery returned true\n")
		return true
	}

	// Get the type information for debugging
	t := reflect.TypeOf(q)
	fmt.Printf("IsReadOnlyQuery returned false for type: %v\n", t)

	// Handle both pointer and non-pointer types
	if t.Kind() == reflect.Ptr {
		t = t.Elem()
	}

	// Workaround!!
	// Check if it embeds *SelectQuery
	for i := 0; i < t.NumField(); i++ {
		if t.Field(i).Type == reflect.TypeOf(&bun.SelectQuery{}) {
			fmt.Printf("Found embedded *SelectQuery\n")
			return true
		}
	}
	return false
}

func (h *RoutingHook) BeforeQuery(ctx context.Context, event *bun.QueryEvent) context.Context {
	if event == nil || event.IQuery == nil {
		return ctx
	}

	fmt.Printf("\nBEFORE QUERY:\n")
	fmt.Printf("Query type: %T\n", event.IQuery)
	fmt.Printf("Is read operation: %v\n", h.isReadOperation(event.IQuery))
	fmt.Printf("Query string: %s\n", event.Query)

	return ctx
}

func (h *RoutingHook) AfterQuery(ctx context.Context, event *bun.QueryEvent) {
}

func main() {
	// Create an in-memory SQLite database
	sqldb, err := sql.Open(sqliteshim.ShimName, "file::memory:?cache=shared")
	if err != nil {
		log.Fatal(err)
	}
	defer sqldb.Close()

	// Create a Bun db instance with routing hook
	db := bun.NewDB(sqldb, sqlitedialect.New())
	db.AddQueryHook(&RoutingHook{})
	defer db.Close()

	ctx := context.Background()

	// Create the users table
	_, err = db.NewCreateTable().Model((*User)(nil)).Exec(ctx)
	if err != nil {
		log.Fatal(err)
	}

	// Insert some test data
	user := &User{Name: "John Doe"}
	_, err = db.NewInsert().Model(user).Exec(ctx)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("\nTesting query routing behavior:")
	fmt.Println("----------------------------------")

	// Test 1: Basic Select Query
	fmt.Println("\nTest 1: Basic SELECT")
	users := make([]User, 0)
	err = db.NewSelect().Model(&users).Scan(ctx)
	if err != nil {
		log.Fatal(err)
	}

	// Test 2: Count Query
	fmt.Println("\nTest 2: COUNT")
	count, err := db.NewSelect().Model(&User{}).Count(ctx)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Count result: %d\n", count)

	// Test 3: Exists Query
	fmt.Println("\nTest 3: EXISTS")
	exists, err := db.NewSelect().Model(&User{}).Exists(ctx)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Exists result: %v\n", exists)
}

[nb-park]

@vmihailenco I appreciate the feedback, please take another look when you get a chance.