rework scanner API to handle errors better

Signed-off-by: oppiliappan <[e-mail]>

scanner.go

···
 	onError func(err error)
 }
 
-type ScannerOpt[T any] func(*Scanner[T])
-
-func OnScannerError[T any](errFunc func(error)) ScannerOpt[T] {
-	return func(s *Scanner[T]) {
-		s.onError = errFunc
-	}
-}
-
-func NewScanner[T any](rows *sql.Rows, opts ...ScannerOpt[T]) Scanner[T] {
-	scanner := Scanner[T]{
+func NewScanner[T any](rows *sql.Rows) Scanner[T] {
+	return Scanner[T]{
 		rows: rows,
 	}
-
-	for _, o := range opts {
-		o(&scanner)
-	}
-
-	return scanner
 }
 
-func (s *Scanner[T]) Scan() iter.Seq[T] {
-	return func(yield func(T) bool) {
+func (s *Scanner[T]) Scan() iter.Seq2[T, error] {
+	return func(yield func(T, error) bool) {
 		for s.rows.Next() {
 			var data T
 			elem := reflect.ValueOf(&data).Elem()
···
 				columns[i] = field.Addr().Interface()
 			}
 
-			if err := s.rows.Scan(columns...); err != nil {
-				s.onError(err)
-				return
-			}
+			err := s.rows.Scan(columns...)
 
-			// Yield the row - if yield returns false, stop iteration
-			if !yield(data) {
+			if !yield(data, err) {
 				return
 			}
 		}
···
 	return s.rows.Close()
 }
 
-func ScanAll[T any](rows *sql.Rows) []T {
+func ScanAll[T any](rows *sql.Rows, dest *[]T) error {
 	scanner := NewScanner[T](rows)
 	defer scanner.Close()
 
-	var elems []T
-	for elem := range scanner.Scan() {
-		elems = append(elems, elem)
+	for elem, err := range scanner.Scan() {
+		if err != nil {
+			return err
+		}
+		*dest = append(*dest, elem)
 	}
 
-	return elems
+	return nil
 }
 
-func ScanOne[T any](rows *sql.Rows) *T {
-	scanner := NewScanner[T](rows)
-	defer scanner.Close()
+func Scan[T any](row *sql.Row, dest *T) error {
+	elem := reflect.ValueOf(dest).Elem()
+	numCols := elem.NumField()
+	columns := make([]any, numCols)
 
-	for elem := range scanner.Scan() {
-		return &elem
+	for i := range numCols {
+		field := elem.Field(i)
+		columns[i] = field.Addr().Interface()
 	}
 
-	return nil
+	return row.Scan(columns...)
 }

scanner_test.go

···
 		t.Fatalf("Failed to query departments: %v", err)
 	}
 
-	departments := ScanAll[Department](rows)
+	var departments []Department
+	err = ScanAll(rows, &departments)
+	if err != nil {
+		t.Fatalf("Failed to scan departments: %v", err)
+	}
 
 	if len(departments) != 3 {
 		t.Errorf("Expected 3 departments, got %d", len(departments))
···
 		t.Fatalf("Failed to query users: %v", err)
 	}
 
-	scanner := NewScanner[UserBasic](rows)
-	defer scanner.Close()
 	var users []UserBasic
-
-	for user := range scanner.Scan() {
-		users = append(users, user)
+	err = ScanAll(rows, &users)
+	if err != nil {
+		t.Fatalf("Failed to scan users: %v", err)
 	}
 
 	if len(users) != 6 {
···
 		t.Fatalf("Failed to query users: %v", err)
 	}
 
-	scanner := NewScanner[User](rows)
-	defer scanner.Close()
 	var users []User
-
-	for user := range scanner.Scan() {
-		users = append(users, user)
+	err = ScanAll(rows, &users)
+	if err != nil {
+		t.Fatalf("Failed to scan users: %v", err)
 	}
 
 	if len(users) != 6 {
···
 	}
 }
 
-func TestScannerWithErrorHandler(t *testing.T) {
-	db := setupTestDB(t)
-	defer db.Close()
-
-	rows, err := db.Query("SELECT id, name, email FROM users LIMIT 1")
-	if err != nil {
-		t.Fatalf("Failed to query users: %v", err)
-	}
-
-	var capturedError error
-	scanner := NewScanner(rows, OnScannerError[SimpleStruct](func(err error) {
-		capturedError = err
-	}))
-	defer scanner.Close()
-
-	var results []SimpleStruct
-	for result := range scanner.Scan() {
-		results = append(results, result)
-	}
-
-	if capturedError == nil {
-		t.Error("Expected an error to be captured, but none was")
-	}
-
-	if len(results) != 0 {
-		t.Errorf("Expected 0 results due to scan error, got %d", len(results))
-	}
-}
-
 func TestScannerEarlyTermination(t *testing.T) {
 	db := setupTestDB(t)
 	defer db.Close()
···
 	}
 }
 
-func TestScannerWithNilErrorHandler(t *testing.T) {
-	db := setupTestDB(t)
-	defer db.Close()
-
-	rows, err := db.Query("SELECT id, name, email FROM users LIMIT 1")
-	if err != nil {
-		t.Fatalf("Failed to query users: %v", err)
-	}
-
-	scanner := NewScanner[UserBasic](rows)
-	defer scanner.Close()
-	var users []UserBasic
-
-	for user := range scanner.Scan() {
-		users = append(users, user)
-	}
-
-	if len(users) != 1 {
-		t.Errorf("Expected 1 user, got %d", len(users))
-	}
-}
-
 func TestScannerResourceCleanup(t *testing.T) {
 	db := setupTestDB(t)
 	defer db.Close()
···
 		}
 	}
 }
+
+func TestScanOne(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+
+	row := db.QueryRow("SELECT * FROM users WHERE id = 1")
+
+	var u User
+	err := Scan(row, &u)
+	if err != nil {
+		t.Fatalf("Failed to scan user: %v", err)
+	}
+
+	if u.ID != 1 || u.Name != "John Doe" {
+		t.Errorf("user data incorrect: %+v", u)
+	}
+}