fix(finisher_api): resolve FindInBatches cursor primary key from dest schema

FindInBatches builds its batch cursor by reading the primary key of the last
scanned row through Statement.Schema. When a different Model is set (e.g.
Model(A).FindInBatches(&[]B{})), Statement.Schema describes A, whose field index
does not apply to B, so the read returns the wrong field (panic "reflect: Field
index out of range" on older versions, "sql: unsupported type ..." on master),
breaking pagination.

Resolve the primary field from dest's own schema, matched by the Model's
primary-key column name so the cursor value stays in sync with the ORDER BY /
comparison column. Mirrors how Scan already re-parses a mismatched dest. When
dest has no field for that column, fail with ErrPrimaryKeyRequired.

Adds a regression test covering []B and []*B destinations.

Closes #7737

Author: wbrunovieira

finisher_api.go

@@ -191,6 +191,8 @@ func (db *DB) FindInBatches(dest interface{}, batchSize int, fc func(tx *DB, bat
 		queryDB      = tx
 		rowsAffected int64
 		batch        int
+
+		batchPrimaryField *schema.Field // resolved lazily below (#7737)
 	)
 
 	// user specified offset or limit
@@ -238,12 +240,41 @@ func (db *DB) FindInBatches(dest interface{}, batchSize int, fc func(tx *DB, bat
 
 		// Optimize for-break
 		resultsValue := reflect.Indirect(reflect.ValueOf(dest))
-		if result.Statement.Schema.PrioritizedPrimaryField == nil {
-			tx.AddError(ErrPrimaryKeyRequired)
-			break
+
+		// The ORDER BY and cursor comparison use the Model's primary-key column,
+		// but the value is read from the scanned dest rows. When a different
+		// Model is set (e.g. Model(A).FindInBatches(&[]B{})), the Model's field
+		// index doesn't apply to dest's type, so resolve the dest field mapping
+		// to that same primary-key column — keeping column and value in sync and
+		// mirroring how Scan re-parses a mismatched dest (#7737).
+		if batchPrimaryField == nil {
+			modelSchema := result.Statement.Schema
+			if modelSchema == nil || modelSchema.PrioritizedPrimaryField == nil {
+				tx.AddError(ErrPrimaryKeyRequired)
+				break
+			}
+
+			batchPrimaryField = modelSchema.PrioritizedPrimaryField
+			destType := resultsValue.Type().Elem()
+			if destType.Kind() == reflect.Ptr {
+				destType = destType.Elem()
+			}
+			if destType != modelSchema.ModelType {
+				parsed, err := schema.Parse(dest, db.cacheStore, db.NamingStrategy)
+				if err != nil {
+					tx.AddError(err)
+					break
+				}
+				// No dest field maps to the Model's primary-key column: there is
+				// no valid cursor value, so fail rather than risk a wrong-index read.
+				if batchPrimaryField = parsed.LookUpField(modelSchema.PrioritizedPrimaryField.DBName); batchPrimaryField == nil {
+					tx.AddError(ErrPrimaryKeyRequired)
+					break
+				}
+			}
 		}
 
-		primaryValue, zero := result.Statement.Schema.PrioritizedPrimaryField.ValueOf(tx.Statement.Context, resultsValue.Index(resultsValue.Len()-1))
+		primaryValue, zero := batchPrimaryField.ValueOf(tx.Statement.Context, resultsValue.Index(resultsValue.Len()-1))
 		if zero {
 			tx.AddError(ErrPrimaryKeyRequired)
 			break

tests/findinbatches_repro_test.go

@@ -0,0 +1,96 @@
+package tests_test
+
+import (
+	"fmt"
+	"testing"
+
+	"gorm.io/gorm"
+	. "gorm.io/gorm/utils/tests"
+)
+
+// Regression test for go-gorm/gorm#7737:
+// Model(A).FindInBatches(&[]B) must page correctly when B embeds A but has a
+// different field layout. Before the fix, the batch cursor read the primary key
+// through the Model's schema (A) against B's rows, yielding the wrong field
+// (panic on older versions, "unsupported type" SQL error on current master),
+// which broke pagination across batches.
+
+type userExtended struct {
+	User
+	ExtraFoo int64
+}
+
+func TestFindInBatchesModelDestMismatch(t *testing.T) {
+	const total = 5
+	created := make(map[uint]bool, total)
+	for i := 0; i < total; i++ {
+		u := User{Name: "fib_7737"}
+		if err := DB.Create(&u).Error; err != nil {
+			t.Fatalf("Create failed: %v", err)
+		}
+		created[u.ID] = true
+	}
+
+	// query sets a Model that differs from the dest element type, and selects an
+	// extra column that only exists on the dest — forcing the schema mismatch.
+	query := func() *gorm.DB {
+		return DB.Model(&User{}).Where("name = ?", "fib_7737").Select("*, 42 AS extra_foo")
+	}
+
+	// assertPagedOnce verifies every created row was visited exactly once across
+	// batches (no duplicate, no skip) — i.e. the primary-key cursor is correct.
+	assertPagedOnce := func(t *testing.T, seen map[uint]bool, rowsAffected int64) {
+		t.Helper()
+		if int(rowsAffected) != total {
+			t.Fatalf("expected RowsAffected=%d, got %d", total, rowsAffected)
+		}
+		if len(seen) != total {
+			t.Fatalf("expected to page over %d unique rows, saw %d", total, len(seen))
+		}
+		for id := range created {
+			if !seen[id] {
+				t.Fatalf("row id %d was skipped by the cursor", id)
+			}
+		}
+	}
+
+	// batchSize (2) < total (5) forces the primary-key cursor path across batches.
+	t.Run("slice of struct", func(t *testing.T) {
+		var batch []userExtended
+		seen := make(map[uint]bool, total)
+		result := query().FindInBatches(&batch, 2, func(tx *gorm.DB, _ int) error {
+			for _, r := range batch {
+				if r.ExtraFoo != 42 {
+					return fmt.Errorf("ExtraFoo not scanned into dest: got %d", r.ExtraFoo)
+				}
+				if seen[r.ID] {
+					return fmt.Errorf("row id %d visited twice (broken cursor)", r.ID)
+				}
+				seen[r.ID] = true
+			}
+			return nil
+		})
+		if result.Error != nil {
+			t.Fatalf("FindInBatches returned error: %v", result.Error)
+		}
+		assertPagedOnce(t, seen, result.RowsAffected)
+	})
+
+	t.Run("slice of pointer", func(t *testing.T) {
+		var batch []*userExtended
+		seen := make(map[uint]bool, total)
+		result := query().FindInBatches(&batch, 2, func(tx *gorm.DB, _ int) error {
+			for _, r := range batch {
+				if seen[r.ID] {
+					return fmt.Errorf("row id %d visited twice (broken cursor)", r.ID)
+				}
+				seen[r.ID] = true
+			}
+			return nil
+		})
+		if result.Error != nil {
+			t.Fatalf("FindInBatches returned error: %v", result.Error)
+		}
+		assertPagedOnce(t, seen, result.RowsAffected)
+	})
+}