mapper_test.go

package sqlr

import (
	"context"
	"database/sql"
	"errors"
	"fmt"
	"reflect"
	"regexp"
	"strings"
	"sync"
	"testing"
	"time"

	sqlmock "github.com/DATA-DOG/go-sqlmock"
)

// ----------------------------------------------------------------
// Helpers for placeholder counting (Exec tests)
// ----------------------------------------------------------------

func placeholderRegexMapper(d Dialect) *regexp.Regexp {
	switch d {
	case Postgres:
		return regexp.MustCompile(`\$(?:[1-9][0-9]*)`)
	case SQLServer:
		return regexp.MustCompile(`@p(?:[1-9][0-9]*)`)
	default:
		return regexp.MustCompile(`\?`)
	}
}

func countPH(q string, d Dialect) int {
	return len(placeholderRegexMapper(d).FindAllStringIndex(q, -1))
}

// --------------------------------
// Exec: capture query and args
// --------------------------------

type execCatcher struct {
	lastQuery string
	lastArgs  []any
}

type dummyResult struct{ id, rows int64 }

func (d dummyResult) LastInsertId() (int64, error) { return d.id, nil }
func (d dummyResult) RowsAffected() (int64, error) { return d.rows, nil }

func (e *execCatcher) ExecContext(_ context.Context, query string, args ...any) (sql.Result, error) {
	e.lastQuery = query
	e.lastArgs = append([]any(nil), args...)
	return dummyResult{id: 123, rows: int64(len(args))}, nil
}

// TestMapper_Exec_ForwardsQueryAndArgs_AllDialects verifies that, for each
// supported SQL dialect, the builder forwards the final SQL string and the
// bound arguments to the Exec implementation unchanged, and that placeholder
// expansion matches the number of args. It also checks RowsAffected can be read.
func TestMapper_Exec_ForwardsQueryAndArgs_AllDialects(t *testing.T) {
	for _, dc := range allDialects() {
		t.Run(dc.name, func(t *testing.T) {
			ec := &execCatcher{}
			s := New(dc.d)
			b := s.Write("UPDATE t SET x=:x WHERE id IN (:ids) AND code=:c")
			b.Bind(map[string]any{"x": 9, "ids": []int{7, 8, 9}, "c": "k"})
			res, err := b.Exec(ec)
			assertNoError(t, err)

			// query and args were forwarded correctly
			if got, want := len(ec.lastArgs), 5; got != want {
				t.Fatalf("len(args) forwarded = %d, want %d; args=%v", got, want, ec.lastArgs)
			}
			if got := countPH(ec.lastQuery, dc.d); got != 5 {
				t.Fatalf("placeholders in forwarded query = %d, want 5\nQ=%s", got, ec.lastQuery)
			}
			if _, err := res.RowsAffected(); err != nil {
				t.Fatalf("RowsAffected err: %v", err)
			}
		})
	}
}

// --------------------------------
// Query/Scan with sqlmock
// --------------------------------

func newMockDB(t testing.TB) (*sql.DB, sqlmock.Sqlmock) {
	t.Helper()
	db, mock, err := sqlmock.New()
	if err != nil {
		t.Fatalf("sqlmock.New(): %v", err)
	}
	return db, mock
}

type Upper string

func (u *Upper) Scan(src any) error {
	switch v := src.(type) {
	case []byte:
		*u = Upper(strings.ToUpper(string(v)))
	case string:
		*u = Upper(strings.ToUpper(v))
	default:
		return fmt.Errorf("unsupported: %T", src)
	}
	return nil
}

// --------------------------------
// Scan: primitives, struct, errors
// --------------------------------

// TestMapper_Scan_Primitive_OneRow ensures ScanOne can read a single primitive
// value (one row, one column) into a basic Go type.
func TestMapper_Scan_Primitive_OneRow(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	mock.ExpectQuery(".*").WithArgs(7).
		WillReturnRows(sqlmock.NewRows([]string{"v"}).AddRow(42))

	var v int
	err := New(Postgres).Write("SELECT :id").Bind(map[string]any{"id": 7}).ScanOne(db, &v)
	assertNoError(t, err)
	if v != 42 {
		t.Fatalf("got=%d, want 42", v)
	}
}

// TestMapper_Scan_Primitive_NoRows_Error verifies that ScanOne returns
// sql.ErrNoRows when the query produces zero rows.
func TestMapper_Scan_Primitive_NoRows_Error(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	mock.ExpectQuery(".*").WillReturnRows(sqlmock.NewRows([]string{"v"})) // 0 rows

	var v int
	err := New(Postgres).Write("SELECT 1").ScanOne(db, &v)
	if err == nil || err != sql.ErrNoRows {
		t.Fatalf("want sql.ErrNoRows, got %v", err)
	}
}

// TestMapper_Scan_Primitive_MultiRows_Error verifies that ScanOne fails when
// more than one row is returned for a primitive destination.
func TestMapper_Scan_Primitive_MultiRows_Error(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	rows := sqlmock.NewRows([]string{"v"}).AddRow(1).AddRow(2)
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var v int
	err := New(Postgres).Write("SELECT 1").ScanOne(db, &v)
	if err == nil || !strings.Contains(err.Error(), "more than one row") {
		t.Fatalf("expected 'more than one row' error, got %v", err)
	}
}

// TestMapper_Scan_Primitive_MultiColumns_Error ensures ScanOne complains when
// scanning into a primitive but the row has more than one column.
func TestMapper_Scan_Primitive_MultiColumns_Error(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	rows := sqlmock.NewRows([]string{"a", "b"}).AddRow(1, 2)
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var v int
	err := New(Postgres).Write("SELECT 1").ScanOne(db, &v)
	if err == nil || !strings.Contains(err.Error(), "requires 1 column") {
		t.Fatalf("expected error for #columns!=1, got %v", err)
	}
}

// TestMapper_Scan_DestMustBePointer_Error checks that ScanOne validates
// the destination is a non-nil pointer.
func TestMapper_Scan_DestMustBePointer_Error(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()
	mock.ExpectQuery(".*").WillReturnRows(sqlmock.NewRows([]string{"v"}).AddRow(1))

	var notPtr int
	err := New(Postgres).Write("SELECT 1").ScanOne(db, notPtr)
	if err == nil || !strings.Contains(err.Error(), "non-nil pointer") {
		t.Fatalf("expected error: dest not a pointer, got %v", err)
	}
}

// TestMapper_Scan_Struct_Tags_ExtraColsIgnored verifies that ScanOne maps only
// tagged struct fields and silently discards unknown columns.
func TestMapper_Scan_Struct_Tags_ExtraColsIgnored(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Row struct {
		A int    `db:"a"`
		B string `db:"b"`
	}
	rows := sqlmock.NewRows([]string{"a", "b", "ignored"}).
		AddRow(7, "x", "dropme")
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var r Row
	err := New(Postgres).Write("SELECT 1").ScanOne(db, &r)
	assertNoError(t, err)
	if r.A != 7 || r.B != "x" {
		t.Fatalf("got %+v, want {A:7 B:x}", r)
	}
}

// TestMapper_Scan_Struct_PointerField_NULL_OK ensures that a NULL database
// value maps to a nil pointer field in a struct without error.
func TestMapper_Scan_Struct_PointerField_NULL_OK(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Row struct {
		A *int   `db:"a"`
		B string `db:"b"`
	}
	rows := sqlmock.NewRows([]string{"a", "b"}).AddRow(nil, "x")
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var r Row
	err := New(Postgres).Write("SELECT 1").ScanOne(db, &r)
	assertNoError(t, err)
	if r.A != nil || r.B != "x" {
		t.Fatalf("got %+v, want {A:nil B:x}", r)
	}
}

// TestMapper_Scan_Struct_NonPointerField_NULL_Error verifies that a NULL
// database value cannot populate a non-pointer field and should produce an error.
func TestMapper_Scan_Struct_NonPointerField_NULL_Error(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Row struct {
		A int    `db:"a"` // non-pointer
		B string `db:"b"`
	}
	rows := sqlmock.NewRows([]string{"a", "b"}).AddRow(nil, "x") // NULL in a
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var r Row
	err := New(Postgres).Write("SELECT 1").ScanOne(db, &r)
	if err == nil {
		t.Fatalf("expected error for NULL in non-pointer field")
	}
}

// TestMapper_Scan_Struct_FieldImplementsScanner checks that a struct field
// whose type implements sql.Scanner is filled by invoking its Scan method.
func TestMapper_Scan_Struct_FieldImplementsScanner(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Row struct {
		Up Upper `db:"up"`
	}
	rows := sqlmock.NewRows([]string{"up"}).AddRow("ciao")
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var r Row
	err := New(Postgres).Write("SELECT 1").ScanOne(db, &r)
	assertNoError(t, err)
	if r.Up != Upper("CIAO") {
		t.Fatalf("scanner not applied: got %q", r.Up)
	}
}

// TestMapper_Scan_Primitive_ScannerType_Upper_String verifies that a primitive
// destination type implementing sql.Scanner (Upper) is populated from a string
// column using its Scan method.
func TestMapper_Scan_Primitive_ScannerType_Upper_String(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	rows := sqlmock.NewRows([]string{"u"}).AddRow("ciao")
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var u Upper
	err := New(Postgres).Write("SELECT 1").ScanOne(db, &u)
	assertNoError(t, err)

	if u != Upper("CIAO") {
		t.Fatalf("scanner not applied: got=%q, want=CIAO", u)
	}
}

// TestMapper_Scan_Primitive_ScannerType_Upper_Bytes verifies that the same
// Scanner type works when the column is []byte.
func TestMapper_Scan_Primitive_ScannerType_Upper_Bytes(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	rows := sqlmock.NewRows([]string{"u"}).AddRow([]byte("hey"))
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var u Upper
	err := New(Postgres).Write("SELECT 1").ScanOne(db, &u)
	assertNoError(t, err)

	if u != Upper("HEY") {
		t.Fatalf("scanner not applied from []byte: got=%q, want=HEY", u)
	}
}

// TestMapper_Scan_Primitive_ScannerType_Upper_Unsupported_Error ensures that
// when the Scanner returns an error (unsupported type), ScanOne propagates it.
func TestMapper_Scan_Primitive_ScannerType_Upper_Unsupported_Error(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	// Upper.Scan doesn't support int -> should propagate error
	rows := sqlmock.NewRows([]string{"u"}).AddRow(123)
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var u Upper
	err := New(Postgres).Write("SELECT 1").ScanOne(db, &u)
	if err == nil || !strings.Contains(err.Error(), "unsupported") {
		t.Fatalf("expected error from scanner, got: %v", err)
	}
}

// TestMapper_Scan_Primitive_ScannerType_NullString validates support for
// stdlib Scanner types like sql.NullString for single-column results.
func TestMapper_Scan_Primitive_ScannerType_NullString(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	rows := sqlmock.NewRows([]string{"s"}).AddRow("ok")
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var ns sql.NullString
	err := New(Postgres).Write("SELECT 1").ScanOne(db, &ns)
	assertNoError(t, err)

	if !ns.Valid || ns.String != "ok" {
		t.Fatalf("sql.NullString mismatch: %+v", ns)
	}
}

// TestMapper_Scan_Primitive_ScannerType_NullString_MultiCols_Error ensures
// that a Scanner destination used as a primitive still requires exactly one
// column in the result set.
func TestMapper_Scan_Primitive_ScannerType_NullString_MultiCols_Error(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	rows := sqlmock.NewRows([]string{"a", "b"}).AddRow("ok", "extra")
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var ns sql.NullString
	err := New(Postgres).Write("SELECT 1").ScanOne(db, &ns)
	if err == nil || !strings.Contains(err.Error(), "requires 1 column") {
		t.Fatalf("expected error for #columns!=1, got %v", err)
	}
}

// TestAmbiguousField_Scan_Error verifies that scanning into a struct with
// ambiguous field mappings (same tag on multiple fields) returns
// ErrFieldAmbiguous.
func TestAmbiguousField_Scan_Error(t *testing.T) {
	type A struct {
		ID int `db:"id"`
	}
	type B struct {
		ID int `db:"id"`
	}
	type C struct {
		A A
		B B
	}

	db, mock := newMockDB(t)
	defer db.Close()

	// One column named "id" -> mapping is ambiguous between A.ID and B.ID
	rows := sqlmock.NewRows([]string{"id"}).AddRow(7)
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var c C
	err := New(Postgres).Write("SELECT 1").ScanOne(db, &c)
	if err == nil || !errors.Is(err, ErrFieldAmbiguous) {
		t.Fatalf("expected ErrFieldAmbiguous, got %v", err)
	}
}

// ----------------------------------------------------------------
// ScanAll: slice of struct, *struct, primitives, errors
// ----------------------------------------------------------------

// TestMapper_ScanAll_SliceOfStruct checks that ScanAll can build a slice of
// structs from multiple rows with tagged columns.
func TestMapper_ScanAll_SliceOfStruct(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Row struct {
		ID   int    `db:"id"`
		Name string `db:"name"`
	}
	rows := sqlmock.NewRows([]string{"id", "name"}).
		AddRow(1, "a").
		AddRow(2, "b").
		AddRow(3, "c")
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var out []Row
	err := New(Postgres).Write("SELECT 1").ScanAll(db, &out)
	assertNoError(t, err)
	if len(out) != 3 || out[0].ID != 1 || out[2].Name != "c" {
		t.Fatalf("slice struct mismatch: %+v", out)
	}
}

// TestMapper_ScanAll_SliceOfPtrStruct ensures ScanAll supports slices of
// pointers to structs and properly allocates each element.
func TestMapper_ScanAll_SliceOfPtrStruct(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Row struct {
		X int `db:"x"`
	}
	rows := sqlmock.NewRows([]string{"x"}).AddRow(10).AddRow(20)
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var out []*Row
	err := New(Postgres).Write("SELECT 1").ScanAll(db, &out)
	assertNoError(t, err)
	if len(out) != 2 || out[0].X != 10 || out[1].X != 20 {
		t.Fatalf("slice *struct mismatch: %+v", out)
	}
}

// TestMapper_ScanAll_SliceOfPrimitives_OneColumn verifies that ScanAll can
// collect a single-column result set into a slice of primitives.
func TestMapper_ScanAll_SliceOfPrimitives_OneColumn(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	rows := sqlmock.NewRows([]string{"v"}).AddRow(1).AddRow(2).AddRow(3)
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var out []int
	err := New(Postgres).Write("SELECT 1").ScanAll(db, &out)
	assertNoError(t, err)
	if !reflect.DeepEqual(out, []int{1, 2, 3}) {
		t.Fatalf("got=%v, want [1 2 3]", out)
	}
}

// TestMapper_ScanAll_DestMustBePointerToSlice_Error validates that ScanAll
// checks the destination is a pointer to a slice (and not something else).
func TestMapper_ScanAll_DestMustBePointerToSlice_Error(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	// 1st call: dest not a pointer -> need 1 ExpectQuery
	mock.ExpectQuery(".*").WillReturnRows(sqlmock.NewRows([]string{"v"}).AddRow(1))
	var notPtr []int
	err := New(Postgres).Write("SELECT 1").ScanAll(db, notPtr)
	if err == nil || !strings.Contains(err.Error(), "non-nil pointer") {
		t.Fatalf("expected error: dest not a pointer, got %v", err)
	}

	// 2nd call: dest pointer but not a slice -> need another ExpectQuery
	mock.ExpectQuery(".*").WillReturnRows(sqlmock.NewRows([]string{"v"}).AddRow(1))
	var notSlice int
	err = New(Postgres).Write("SELECT 1").ScanAll(db, &notSlice)
	if err == nil || !strings.Contains(err.Error(), "pointer to slice") {
		t.Fatalf("expected error: dest not a slice, got %v", err)
	}
}

// TestMapper_ScanAll_PrimitiveSlice_MultiColumns_Error ensures that when
// building a slice of primitives, the query must return exactly one column.
func TestMapper_ScanAll_PrimitiveSlice_MultiColumns_Error(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	rows := sqlmock.NewRows([]string{"a", "b"}).AddRow(1, 2)
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var out []int
	err := New(Postgres).Write("SELECT 1").ScanAll(db, &out)
	if err == nil || !strings.Contains(err.Error(), "requires 1 column") {
		t.Fatalf("expected error for #columns!=1, got %v", err)
	}
}

// TestMapper_ScanAll_ScannerAndPtr_ResetPerRow verifies that scanner fields
// and pointer holders are correctly reset between rows, so previous non-nil
// values do not leak into subsequent rows.
func TestMapper_ScanAll_ScannerAndPtr_ResetPerRow(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Row struct {
		U Upper `db:"u"` // ckScanner: *Upper implements sql.Scanner
		P *int  `db:"p"` // ckPtr
	}

	rows := sqlmock.NewRows([]string{"u", "p"}).
		AddRow("ciao", 7). // first row: P non-nil
		AddRow("x", nil)   // second row: P should be nil after holder reset

	mock.ExpectQuery(".*").WillReturnRows(rows)

	var out []Row
	err := New(Postgres).Write("SELECT 1").ScanAll(db, &out)
	assertNoError(t, err)

	if len(out) != 2 {
		t.Fatalf("len(out)=%d, want 2", len(out))
	}
	if out[0].U != Upper("CIAO") {
		t.Fatalf("scanner not applied on row 0: %q", out[0].U)
	}
	if out[0].P == nil || *out[0].P != 7 {
		t.Fatalf("r0.P got=%v, want 7", out[0].P)
	}
	if out[1].U != Upper("X") {
		t.Fatalf("scanner not applied on row 1: %q", out[1].U)
	}
	if out[1].P != nil {
		t.Fatalf("r1.P should be nil after reset, got=%v", *out[1].P)
	}
}

// TestMapper_ScanAll_PointerToScannerType ensures that pointer-to-Scanner leaf
// fields are allocated when non-NULL and left nil when NULL.
func TestMapper_ScanAll_PointerToScannerType(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Row struct {
		U *Upper `db:"u"` // ckPtr, but *Upper has Scan
	}

	rows := sqlmock.NewRows([]string{"u"}).
		AddRow("hello").
		AddRow(nil)

	mock.ExpectQuery(".*").WillReturnRows(rows)

	var out []Row
	err := New(Postgres).Write("SELECT 1").ScanAll(db, &out)
	assertNoError(t, err)

	if len(out) != 2 {
		t.Fatalf("len(out)=%d, want 2", len(out))
	}
	if out[0].U == nil || *out[0].U != Upper("HELLO") {
		t.Fatalf("row0.U got=%v, want HELLO", out[0].U)
	}
	if out[1].U != nil {
		t.Fatalf("row1.U should be nil, got=%v", out[1].U)
	}
}

// TestMapper_ScanAll_SliceOfPtrStruct_PointerToScannerType ensures that when
// scanning into a slice of *struct and the destination field is *T where *T
// implements sql.Scanner, we capture the raw value into a sink, then post-process:
// - allocate *T and call Scan for non-NULL
// - keep nil for NULL.
func TestMapper_ScanAll_SliceOfPtrStruct_PointerToScannerType(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Row struct {
		U *Upper `db:"u"` // *Upper implements sql.Scanner
	}

	rows := sqlmock.NewRows([]string{"u"}).
		AddRow("hello").
		AddRow(nil)
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var out []*Row
	err := New(Postgres).Write("SELECT 1").ScanAll(db, &out)
	assertNoError(t, err)

	if len(out) != 2 {
		t.Fatalf("len(out)=%d, want 2", len(out))
	}
	if out[0] == nil || out[0].U == nil || *out[0].U != Upper("HELLO") {
		t.Fatalf("row0.U got=%v, want *Upper(\"HELLO\")", out[0].U)
	}
	if out[1] == nil || out[1].U != nil {
		t.Fatalf("row1.U should be nil, got=%v", out[1].U)
	}
}

// TestMapper_ScanAll_SliceOfPtrStruct_ValueScannerViaPtrReceiver ensures that when
// scanning into a slice of *struct and the destination field is a value T whose *T
// implements sql.Scanner (pointer receiver), we pass &T directly to rows.Scan.
func TestMapper_ScanAll_SliceOfPtrStruct_ValueScannerViaPtrReceiver(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Row struct {
		Up Upper `db:"up"` // value field; *Upper implements sql.Scanner
	}

	rows := sqlmock.NewRows([]string{"up"}).
		AddRow("ciao").
		AddRow([]byte("hey"))
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var out []*Row
	err := New(Postgres).Write("SELECT 1").ScanAll(db, &out)
	assertNoError(t, err)

	if len(out) != 2 {
		t.Fatalf("len(out)=%d, want 2", len(out))
	}
	if out[0] == nil || out[0].Up != Upper("CIAO") {
		t.Fatalf("row0.Up scanner not applied: %+v", out[0])
	}
	if out[1] == nil || out[1].Up != Upper("HEY") {
		t.Fatalf("row1.Up scanner not applied: %+v", out[1])
	}
}

// TestMapper_ScanAll_FieldByIndexAlloc_IntermediatePtr_ckValue
// Verifica che con un puntatore intermedio nel path (Row.Inner *Inner)
// e un leaf NON-Scanner (int), scanAll usi fieldByIndexAlloc per raggiungere
// il campo e allochi i nodi pointer intermedi.
func TestMapper_ScanAll_FieldByIndexAlloc_IntermediatePtr_ckValue(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Inner struct {
		A int `db:"a"`
	}
	type Row struct {
		Inner *Inner
	}

	rows := sqlmock.NewRows([]string{"a"}).
		AddRow(5).
		AddRow(7)
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var out []Row
	err := New(Postgres).Write("SELECT 1").ScanAll(db, &out)
	assertNoError(t, err)

	if len(out) != 2 {
		t.Fatalf("len(out)=%d, want 2", len(out))
	}
	// Il puntatore intermedio deve essere allocato e valorizzato.
	if out[0].Inner == nil || out[0].Inner.A != 5 {
		t.Fatalf("row0.Inner alloc/scan failed: %+v", out[0])
	}
	if out[1].Inner == nil || out[1].Inner.A != 7 {
		t.Fatalf("row1.Inner alloc/scan failed: %+v", out[1])
	}
}

// TestMapper_ScanAll_FieldByIndexAlloc_IntermediatePtr_ckScanner_ValueLeaf
// Verifica che con un puntatore intermedio e un leaf che implementa Scanner come value
// (Upper: *Upper implementa sql.Scanner), scanAll usi fieldByIndexAlloc per ottenere &T.
func TestMapper_ScanAll_FieldByIndexAlloc_IntermediatePtr_ckScanner_ValueLeaf(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Inner struct {
		U Upper `db:"u"` // value; *Upper implements sql.Scanner
	}
	type Row struct {
		Inner *Inner
	}

	rows := sqlmock.NewRows([]string{"u"}).
		AddRow("ciao").
		AddRow([]byte("hey"))
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var out []Row
	err := New(Postgres).Write("SELECT 1").ScanAll(db, &out)
	assertNoError(t, err)

	if len(out) != 2 {
		t.Fatalf("len(out)=%d, want 2", len(out))
	}
	if out[0].Inner == nil || out[0].Inner.U != Upper("CIAO") {
		t.Fatalf("row0.Inner.U scanner not applied: %+v", out[0])
	}
	if out[1].Inner == nil || out[1].Inner.U != Upper("HEY") {
		t.Fatalf("row1.Inner.U scanner not applied: %+v", out[1])
	}
}

// TestMapper_ScanAll_FieldByIndexAlloc_IntermediatePtr_ckScanner_PtrLeaf
// Verifica che con un puntatore intermedio e un leaf *Scanner (U *Upper, dove *Upper implementa Scanner)
// venga usato il percorso con sink + post-processing, e fieldByIndexAlloc nel post-set.
func TestMapper_ScanAll_FieldByIndexAlloc_IntermediatePtr_ckScanner_PtrLeaf(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Inner struct {
		U *Upper `db:"u"` // *Upper implements sql.Scanner (ckScanner branch con ptrScannerIdx)
	}
	type Row struct {
		Inner *Inner
	}

	rows := sqlmock.NewRows([]string{"u"}).
		AddRow("hello"). // non-NULL -> alloc e Scan su *Upper
		AddRow(nil)      // NULL -> lascia nil
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var out []Row
	err := New(Postgres).Write("SELECT 1").ScanAll(db, &out)
	assertNoError(t, err)

	if len(out) != 2 {
		t.Fatalf("len(out)=%d, want 2", len(out))
	}
	// r0: Inner allocato, U allocato e uppercased
	if out[0].Inner == nil || out[0].Inner.U == nil || *out[0].Inner.U != Upper("HELLO") {
		t.Fatalf("row0.Inner.U got=%v, want *Upper(\"HELLO\")", out[0].Inner.U)
	}
	// r1: Inner viene comunque allocato (intermedio), ma leaf U deve restare nil per NULL
	if out[1].Inner == nil {
		t.Fatalf("row1.Inner should be allocated (intermediate ptr), got nil")
	}
	if out[1].Inner.U != nil {
		t.Fatalf("row1.Inner.U should be nil on NULL, got=%v", *out[1].Inner.U)
	}
}

// TestMapper_ScanAll_PtrSlice_FieldByIndexAlloc_IntermediatePtr_ckValue
// Copre: ramo isPtr=true, hasPtrPath=true, case ckValue → fv = fieldByIndexAlloc(...)
func TestMapper_ScanAll_PtrSlice_FieldByIndexAlloc_IntermediatePtr_ckValue(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Inner struct {
		A int `db:"a"`
	}
	type Row struct {
		Inner *Inner
	}

	rows := sqlmock.NewRows([]string{"a"}).
		AddRow(11).
		AddRow(22)
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var out []*Row
	err := New(Postgres).Write("SELECT 1").ScanAll(db, &out)
	assertNoError(t, err)

	if len(out) != 2 {
		t.Fatalf("len(out)=%d, want 2", len(out))
	}
	if out[0] == nil || out[0].Inner == nil || out[0].Inner.A != 11 {
		t.Fatalf("row0.Inner alloc/scan failed: %+v", out[0])
	}
	if out[1] == nil || out[1].Inner == nil || out[1].Inner.A != 22 {
		t.Fatalf("row1.Inner alloc/scan failed: %+v", out[1])
	}
}

// TestMapper_ScanAll_PtrSlice_FieldByIndexAlloc_IntermediatePtr_ckScanner_ValueLeaf
// Copre: ramo isPtr=true, hasPtrPath=true, case ckScanner (leaf value con *Upper Scanner) → fv = fieldByIndexAlloc(...)
func TestMapper_ScanAll_PtrSlice_FieldByIndexAlloc_IntermediatePtr_ckScanner_ValueLeaf(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Inner struct {
		U Upper `db:"u"` // value; *Upper implementa sql.Scanner
	}
	type Row struct {
		Inner *Inner
	}

	rows := sqlmock.NewRows([]string{"u"}).
		AddRow("ciao").
		AddRow([]byte("hey"))
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var out []*Row
	err := New(Postgres).Write("SELECT 1").ScanAll(db, &out)
	assertNoError(t, err)

	if len(out) != 2 {
		t.Fatalf("len(out)=%d, want 2", len(out))
	}
	if out[0] == nil || out[0].Inner == nil || out[0].Inner.U != Upper("CIAO") {
		t.Fatalf("row0.Inner.U scanner not applied: %+v", out[0])
	}
	if out[1] == nil || out[1].Inner == nil || out[1].Inner.U != Upper("HEY") {
		t.Fatalf("row1.Inner.U scanner not applied: %+v", out[1])
	}
}

// TestMapper_ScanAll_PtrSlice_FieldByIndexAlloc_IntermediatePtr_ckScanner_PtrLeaf
// Copre: ramo isPtr=true, hasPtrPath=true, case ckScanner (leaf pointer *Upper) →
//   - in preparazione target: fv = fieldByIndexAlloc(...) (anche se si usa sink+post)
//   - in post-processing: fv = fieldByIndexAlloc(...) per assegnare *Upper/non-nil o nil
func TestMapper_ScanAll_PtrSlice_FieldByIndexAlloc_IntermediatePtr_ckScanner_PtrLeaf(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Inner struct {
		U *Upper `db:"u"` // *Upper implementa sql.Scanner
	}
	type Row struct {
		Inner *Inner
	}

	rows := sqlmock.NewRows([]string{"u"}).
		AddRow("hello"). // non-NULL → alloc + Scan
		AddRow(nil)      // NULL → resta nil
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var out []*Row
	err := New(Postgres).Write("SELECT 1").ScanAll(db, &out)
	assertNoError(t, err)

	if len(out) != 2 {
		t.Fatalf("len(out)=%d, want 2", len(out))
	}
	if out[0] == nil || out[0].Inner == nil || out[0].Inner.U == nil || *out[0].Inner.U != Upper("HELLO") {
		t.Fatalf("row0.Inner.U got=%v, want *Upper(\"HELLO\")", out[0])
	}
	if out[1] == nil || out[1].Inner == nil {
		t.Fatalf("row1.Inner should be allocated (intermediate ptr)")
	}
	if out[1].Inner.U != nil {
		t.Fatalf("row1.Inner.U should be nil on NULL, got=%v", *out[1].Inner.U)
	}
}

// TestMapper_Scan_PointerToScannerType_ScanOne covers ScanOne behavior with a
// pointer-to-Scanner field: it is allocated and scanned for non-NULL, and
// remains nil for NULL values.
func TestMapper_Scan_PointerToScannerType_ScanOne(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Row struct {
		U *Upper `db:"u"`
	}

	// 1) non-NULL value -> U must be non-nil and uppercase
	rows1 := sqlmock.NewRows([]string{"u"}).AddRow("hello")
	mock.ExpectQuery(".*").WillReturnRows(rows1)

	var r1 Row
	err := New(Postgres).Write("SELECT 1").ScanOne(db, &r1)
	assertNoError(t, err)
	if r1.U == nil || *r1.U != Upper("HELLO") {
		t.Fatalf("got=%v, want *Upper(\"HELLO\")", r1.U)
	}

	// 2) NULL value -> U must remain nil
	rows2 := sqlmock.NewRows([]string{"u"}).AddRow(nil)
	mock.ExpectQuery(".*").WillReturnRows(rows2)

	var r2 Row
	err = New(Postgres).Write("SELECT 1").ScanOne(db, &r2)
	assertNoError(t, err)
	if r2.U != nil {
		t.Fatalf("want nil, got=%v", r2.U)
	}
}

// TestMapper_ScanAll_MultiPtr_ResetEveryRow verifies that multiple pointer
// fields are independently reset per row so NULLs are represented as nil
// pointers and non-NULLs are properly allocated and assigned.
func TestMapper_ScanAll_MultiPtr_ResetEveryRow(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Row struct {
		A *int    `db:"a"`
		B *string `db:"b"`
	}

	rows := sqlmock.NewRows([]string{"a", "b"}).
		AddRow(1, "x").
		AddRow(nil, "y").
		AddRow(3, nil)

	mock.ExpectQuery(".*").WillReturnRows(rows)

	var out []Row
	err := New(Postgres).Write("SELECT 1").ScanAll(db, &out)
	assertNoError(t, err)

	if len(out) != 3 {
		t.Fatalf("len(out)=%d, want 3", len(out))
	}
	// r0: both set
	if out[0].A == nil || *out[0].A != 1 || out[0].B == nil || *out[0].B != "x" {
		t.Fatalf("row0 mismatch: %+v", out[0])
	}
	// r1: A nil, B set
	if out[1].A != nil || out[1].B == nil || *out[1].B != "y" {
		t.Fatalf("row1 mismatch: %+v", out[1])
	}
	// r2: A set, B nil
	if out[2].A == nil || *out[2].A != 3 || out[2].B != nil {
		t.Fatalf("row2 mismatch: %+v", out[2])
	}
}

// TestMapper_ScanAll_AllColsAreSinks_EmptyStruct confirms that queries whose
// columns do not map to any struct fields (empty struct) are still consumed
// without error and produce the correct number of rows.
func TestMapper_ScanAll_AllColsAreSinks_EmptyStruct(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	// No fields -> all columns go to ckSink
	type Row struct{}

	rows := sqlmock.NewRows([]string{"x", "y"}).
		AddRow(1, "a").
		AddRow(2, "b")
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var out []Row
	err := New(Postgres).Write("SELECT 1").ScanAll(db, &out)
	assertNoError(t, err)

	if len(out) != 2 {
		t.Fatalf("len(out)=%d, want 2", len(out))
	}
}

// TestMapper_ScanAll_MixedCols_SomeSinks_SomeMapped verifies that unmapped
// columns are ignored while mapped columns are properly assigned.
func TestMapper_ScanAll_MixedCols_SomeSinks_SomeMapped(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	// "a" and "b" mapped, "ignored" goes to ckSink
	type Row struct {
		A int    `db:"a"`
		B string `db:"b"`
	}

	rows := sqlmock.NewRows([]string{"a", "ignored", "b"}).
		AddRow(7, "dropme", "x").
		AddRow(8, "also_drop", "y")
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var out []Row
	err := New(Postgres).Write("SELECT 1").ScanAll(db, &out)
	assertNoError(t, err)

	if len(out) != 2 {
		t.Fatalf("len(out)=%d, want 2", len(out))
	}
	if out[0].A != 7 || out[0].B != "x" {
		t.Fatalf("row0 mismatch: %+v", out[0])
	}
	if out[1].A != 8 || out[1].B != "y" {
		t.Fatalf("row1 mismatch: %+v", out[1])
	}
}

// TestMapper_ScanAll_SliceOfPtrToNonStruct_OK ensures that ScanAll supports
// slices of pointers to non-struct types (e.g. []*int) and properly allocates
// each element.
func TestMapper_ScanAll_SliceOfPtrToNonStruct_OK(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	mock.ExpectQuery(".*").
		WillReturnRows(sqlmock.NewRows([]string{"v"}).AddRow(1).AddRow(2))

	var out []*int
	err := New(Postgres).Write("SELECT 1 AS v UNION ALL SELECT 2").ScanAll(db, &out)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if len(out) != 2 {
		t.Fatalf("expected 2 rows, got %d", len(out))
	}
	if out[0] == nil || out[1] == nil {
		t.Fatalf("expected non-nil pointers; got %v, %v", out[0], out[1])
	}
	if *out[0] != 1 || *out[1] != 2 {
		t.Fatalf("unexpected values: %d, %d", *out[0], *out[1])
	}
}

// TestMapper_ScanAll_SliceOfPtrToScanner_OK ensures that ScanAll supports
// slices of pointers to Scanner types (e.g. []*sql.NullString), properly
// allocating each element and handling NULLs.
func TestMapper_ScanAll_SliceOfPtrToScanner_OK(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	mock.ExpectQuery(".*").
		WillReturnRows(sqlmock.NewRows([]string{"v"}).AddRow("a").AddRow(nil))

	var out []*sql.NullString
	err := New(Postgres).Write("SELECT 'a' AS v UNION ALL SELECT NULL").ScanAll(db, &out)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if len(out) != 2 || out[0] == nil || out[1] == nil {
		t.Fatalf("bad slice: %#v", out)
	}
	if !out[0].Valid || out[0].String != "a" {
		t.Fatalf("unexpected first value: %#v", out[0])
	}
	if out[1].Valid {
		t.Fatalf("expected second to be NULL/invalid: %#v", out[1])
	}
}

// TestMapper_ScanAll_SliceOfStructScanner_OK ensures that ScanAll supports
// slices of struct types that implement sql.Scanner (via *T or T) with exactly
// one column, e.g. []sql.NullString. Each element must be allocated/filled
// correttamente usando rows.Scan(&elem).
func TestMapper_ScanAll_SliceOfStructScanner_OK(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	// Due righe: una stringa e un NULL → la prima deve diventare Valid=true,
	// la seconda Valid=false su sql.NullString.
	mock.ExpectQuery(".*").
		WillReturnRows(sqlmock.NewRows([]string{"v"}).
			AddRow("a").
			AddRow(nil))

	var out []sql.NullString // <- struct, non pointer; deve entrare nel Case C
	err := New(Postgres).
		Write("SELECT 'a' AS v UNION ALL SELECT NULL").
		ScanAll(db, &out)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	if len(out) != 2 {
		t.Fatalf("expected 2 rows, got %d", len(out))
	}

	if !out[0].Valid || out[0].String != "a" {
		t.Fatalf("unexpected first value: %#v", out[0])
	}
	if out[1].Valid {
		t.Fatalf("expected second to be NULL/invalid: %#v", out[1])
	}

	// Verifica che tutte le aspettative di sqlmock siano state soddisfatte.
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Fatalf("unmet expectations: %v", err)
	}
}

// TestMapper_Scan_Flatten_AnonymousEmbedded ensures that fields from an
// anonymously embedded struct are flattened and mapped by their tags.
func TestMapper_Scan_Flatten_AnonymousEmbedded(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Address struct {
		City string `db:"city"`
		Zip  int    `db:"zip"`
	}
	type Row struct {
		ID      int `db:"id"`
		Address     // anonymous
	}

	rows := sqlmock.NewRows([]string{"id", "city", "zip"}).AddRow(1, "Roma", 10100)
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var out Row
	err := New(Postgres).Write("SELECT 1").ScanOne(db, &out)
	assertNoError(t, err)
	if out.ID != 1 || out.City != "Roma" || out.Zip != 10100 {
		t.Fatalf("scan mismatch: %+v", out)
	}
}

// TestMapper_Scan_Flatten_NamedPtr_AutoAlloc verifies that named pointer
// fields to nested structs are automatically allocated when a leaf column is
// present.
func TestMapper_Scan_Flatten_NamedPtr_AutoAlloc(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Address struct {
		City string `db:"city"`
	}
	type Row struct {
		Addr *Address // should be auto-allocated
	}

	rows := sqlmock.NewRows([]string{"city"}).AddRow("Roma")
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var out Row
	err := New(Postgres).Write("SELECT 1").ScanOne(db, &out)
	assertNoError(t, err)
	if out.Addr == nil || out.Addr.City != "Roma" {
		t.Fatalf("auto-alloc failed: %+v", out)
	}
}

// TestMapper_Scan_Flatten_DeepPtrChain_AutoAlloc ensures that multi-level
// pointer chains are walked and intermediate structs auto-allocated.
func TestMapper_Scan_Flatten_DeepPtrChain_AutoAlloc(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type S2 struct {
		Name string `db:"name"`
	}
	type S1 struct{ P *S2 }
	type Root struct{ S *S1 }

	rows := sqlmock.NewRows([]string{"name"}).AddRow("Zed")
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var r Root
	err := New(Postgres).Write("SELECT 1").ScanOne(db, &r)
	assertNoError(t, err)
	if r.S == nil || r.S.P == nil || r.S.P.Name != "Zed" {
		t.Fatalf("deep auto-alloc failed: %+v", r)
	}
}

// TestMapper_ScanAll_Flatten_NestedPtr_ResetPerRow verifies that pointer
// leaves inside nested structs are reset per row and reflect NULL correctly.
func TestMapper_ScanAll_Flatten_NestedPtr_ResetPerRow(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Address struct {
		City *string `db:"city"` // leaf pointer to handle NULL
	}
	type Row struct {
		Addr *Address
	}

	rows := sqlmock.NewRows([]string{"city"}).
		AddRow("Roma").
		AddRow(nil) // must reset to nil on second row
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var out []Row
	err := New(Postgres).Write("SELECT 1").ScanAll(db, &out)
	assertNoError(t, err)

	if len(out) != 2 {
		t.Fatalf("len(out)=%d, want 2", len(out))
	}
	if out[0].Addr == nil || out[0].Addr.City == nil || *out[0].Addr.City != "Roma" {
		t.Fatalf("row0 mismatch: %+v", out[0])
	}
	if out[1].Addr == nil || out[1].Addr.City != nil {
		t.Fatalf("row1 Addr.City should be nil: %+v", out[1])
	}
}

// TestMapper_ScanAll_ResetLen_ReusesCap_SliceOfStruct tests that when
// ScanAll is given a pre-allocated slice of structs with len>0, it resets
// the length to zero and reuses the existing capacity.
func TestMapper_ScanAll_ResetLen_ReusesCap_SliceOfStruct(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Row struct {
		ID   int    `db:"id"`
		Name string `db:"name"`
	}

	rows := sqlmock.NewRows([]string{"id", "name"}).
		AddRow(1, "a").
		AddRow(2, "b").
		AddRow(3, "c")
	mock.ExpectQuery(".*").WillReturnRows(rows)

	sentinel := Row{ID: 99, Name: "SENTINEL"}
	out := make([]Row, 2, 5)
	out[0], out[1] = sentinel, sentinel

	err := New(Postgres).Write("SELECT 1").ScanAll(db, &out)
	assertNoError(t, err)

	if got := len(out); got != 3 {
		t.Fatalf("len(out)=%d, want 3", got)
	}
	if got := cap(out); got != 5 {
		t.Fatalf("cap(out)=%d, want 5 (cap riusata)", got)
	}
	if out[0].ID != 1 || out[0].Name != "a" || out[1].ID != 2 || out[2].ID != 3 {
		t.Fatalf("contenuto errato dopo reset+scan: %+v", out)
	}
}

// TestMapper_ScanAll_SliceOfPtrStruct_ScannerAndPtr_WithSinkAndReset tests
// that ScanAll can reuse a slice of pointer-to-struct with pre-allocated
// elements, resetting each element and reusing capacity.
func TestMapper_ScanAll_SliceOfPtrStruct_ScannerAndPtr_WithSinkAndReset(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Row struct {
		U Upper `db:"u"` // ckScanner
		P *int  `db:"p"` // ckPtr
	}

	rows := sqlmock.NewRows([]string{"u", "ignored", "p"}).
		AddRow("ciao", "dropme", 7).
		AddRow("x", "also_drop", nil)
	mock.ExpectQuery(".*").WillReturnRows(rows)

	s := &Row{U: Upper("SENT"), P: new(int)}
	out := make([]*Row, 1, 4)
	out[0] = s

	err := New(Postgres).Write("SELECT 1").ScanAll(db, &out)
	assertNoError(t, err)

	if got := len(out); got != 2 {
		t.Fatalf("len(out)=%d, want 2", got)
	}
	if got := cap(out); got != 4 {
		t.Fatalf("cap(out)=%d, want 4 (cap riusata)", got)
	}

	if out[0] == nil || out[0].U != Upper("CIAO") {
		t.Fatalf("row0.U scanner non applicato: %+v", out[0])
	}
	if out[0].P == nil || *out[0].P != 7 {
		t.Fatalf("row0.P atteso 7, got=%v", out[0].P)
	}
	if out[1] == nil || out[1].U != Upper("X") {
		t.Fatalf("row1.U scanner non applicato: %+v", out[1])
	}
	if out[1].P != nil {
		t.Fatalf("row1.P atteso nil, got=%v", *out[1].P)
	}
}

// TestMapper_Scan_Flatten_ScannerLeafInNested checks that scanner-typed
// leaves inside nested structs are correctly scanned.
func TestMapper_Scan_Flatten_ScannerLeafInNested(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Payload struct {
		U Upper `db:"up"` // Upper implements sql.Scanner
	}
	type Row struct {
		P *Payload
	}

	rows := sqlmock.NewRows([]string{"up"}).AddRow("ciao")
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var out Row
	err := New(Postgres).Write("SELECT 1").ScanOne(db, &out)
	assertNoError(t, err)
	if out.P == nil || out.P.U != Upper("CIAO") {
		t.Fatalf("nested scanner not applied: %+v", out)
	}
}

// TestMapper_Scan_Flatten_TimeLeafInNested ensures time.Time leaves inside
// nested structs are mapped as-is.
func TestMapper_Scan_Flatten_TimeLeafInNested(t *testing.T) {
	db, mock := newMockDB(t)
	defer db.Close()

	type Audit struct {
		CreatedAt time.Time `db:"created_at"`
	}
	type Row struct {
		A *Audit
	}
	now := time.Now()

	rows := sqlmock.NewRows([]string{"created_at"}).AddRow(now)
	mock.ExpectQuery(".*").WillReturnRows(rows)

	var out Row
	err := New(Postgres).Write("SELECT 1").ScanOne(db, &out)
	assertNoError(t, err)
	if out.A == nil || !out.A.CreatedAt.Equal(now) {
		t.Fatalf("time leaf mismatch: %+v (want %v)", out, now)
	}
}

// TestScanAll_AmbiguousField_InMakeScanPlan_AllDialects verifies that, across
// all dialects, ScanAll fails with ErrFieldAmbiguous when two struct fields
// map to the same column name.
func TestScanAll_AmbiguousField_InMakeScanPlan_AllDialects(t *testing.T) {
	for _, dc := range allDialects() {
		t.Run(dc.name, func(t *testing.T) {
			db, mock := newMockDB(t)
			defer db.Close()

			// Una singola colonna "id" per innescare il mapping ambiguo.
			rows := sqlmock.NewRows([]string{"id"}).AddRow(7)
			mock.ExpectQuery(".*").WillReturnRows(rows)

			// Struct con collisione intenzionale: due campi con lo stesso nome/tag "id".
			type Amb struct {
				X int `db:"id"`
				Y int `db:"id"`
			}

			var out []Amb
			err := New(dc.d).Write("SELECT 1").ScanAll(db, &out)

			if err == nil || !errors.Is(err, ErrFieldAmbiguous) {
				t.Fatalf("[%s] expected ErrFieldAmbiguous, got: %v", dc.name, err)
			}
			if err != nil && !strings.Contains(err.Error(), `"id"`) {
				t.Fatalf("[%s] error should mention the conflicting column name \"id\": %v", dc.name, err)
			}
		})
	}
}

// TestBuildScanPlan_AmbiguousField_Direct checks that ambiguity is detected
// when two fields map to the same column name, without running a query.
func TestBuildScanPlan_AmbiguousField_Direct(t *testing.T) {
	type Amb struct {
		X int `db:"id"`
		Y int `db:"id"`
	}
	cols := []string{"id"}

	_, err := buildScanPlan(cols, reflect.TypeOf(Amb{}))
	if err == nil || !errors.Is(err, ErrFieldAmbiguous) {
		t.Fatalf("expected ErrFieldAmbiguous, got: %v", err)
	}
}

// TestGetScanPlan_CacheHitSamePointer ensures that requesting the same plan
// (same destination struct type and same ordered columns) returns the same pointer.
func TestGetScanPlan_CacheHitSamePointer(t *testing.T) {
	type Row struct {
		ID   int    `db:"id"`
		Name string `db:"name"`
	}
	cols := []string{"id", "name"}

	p1, err := getScanPlan(cols, reflect.TypeOf(Row{}))
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	p2, err := getScanPlan(cols, reflect.TypeOf(Row{}))
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if p1 != p2 {
		t.Fatalf("expected same plan pointer from cache, got different pointers")
	}
}

// TestGetScanPlan_DifferentColumnsDifferentPlan ensures that different column
// signatures lead to different cached plans.
func TestGetScanPlan_DifferentColumnsDifferentPlan(t *testing.T) {
	type Row struct {
		ID   int    `db:"id"`
		Name string `db:"name"`
	}
	cols1 := []string{"id", "name"}
	cols2 := []string{"name", "id"} // order matters

	p1, err := getScanPlan(cols1, reflect.TypeOf(Row{}))
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	p2, err := getScanPlan(cols2, reflect.TypeOf(Row{}))
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if p1 == p2 {
		t.Fatalf("expected different plan pointers for different column signatures")
	}
}

// TestGetScanPlan_PointerAndValueSamePlan ensures that passing a pointer type or a
// value type for the destination results in the same canonical plan.
func TestGetScanPlan_PointerAndValueSamePlan(t *testing.T) {
	type Row struct {
		ID int `db:"id"`
	}
	cols := []string{"id"}

	pVal, err := getScanPlan(cols, reflect.TypeOf(Row{}))
	if err != nil {
		t.Fatalf("unexpected error (value): %v", err)
	}
	pPtr, err := getScanPlan(cols, reflect.TypeOf(&Row{}))
	if err != nil {
		t.Fatalf("unexpected error (pointer): %v", err)
	}
	if pVal != pPtr {
		t.Fatalf("expected same plan pointer for value and pointer destination types")
	}
}

// TestGetScanPlan_Concurrent checks that concurrent access to the plan cache
// does not race and consistently returns non-nil plans.
func TestGetScanPlan_Concurrent(t *testing.T) {
	type Row struct {
		A int    `db:"a"`
		B string `db:"b"`
	}
	cols := []string{"a", "b"}

	var wg sync.WaitGroup
	errCh := make(chan error, 50)

	for i := 0; i < 50; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			p, err := getScanPlan(cols, reflect.TypeOf(Row{}))
			if err != nil {
				errCh <- err
				return
			}
			if p == nil {
				errCh <- errors.New("nil plan returned")
				return
			}
		}()
	}
	wg.Wait()
	close(errCh)

	for err := range errCh {
		if err != nil {
			t.Fatalf("concurrent getScanPlan failed: %v", err)
		}
	}
}

// TestPlanCache_Get_PromotesFromPrev verifies that when a key is found in the
// previous generation (prev), get() promotes it into the current generation (curr)
// without rotating (when curr is not full).
func TestPlanCache_Get_PromotesFromPrev(t *testing.T) {
	pc := newPlanCache(2) // small max to control rotations
	p1 := &scanPlan{}
	p2 := &scanPlan{}
	p3 := &scanPlan{}

	// Create three distinct keys so that after the third put:
	// prev = {k1, k2}, curr = {k3}
	k1 := planKey{dstType: reflect.TypeOf(struct{ A int }{}), sig: "id"}
	k2 := planKey{dstType: reflect.TypeOf(struct{ B int }{}), sig: "id"}
	k3 := planKey{dstType: reflect.TypeOf(struct{ C int }{}), sig: "id"}

	// Fill curr to capacity, then trigger rotation on the third put.
	pc.put(k1, p1) // curr = {k1}
	pc.put(k2, p2) // curr = {k1, k2}
	pc.put(k3, p3) // rotation: prev = {k1, k2}, curr = {k3}

	// Sanity check preconditions.
	if len(pc.prev) != 2 || len(pc.curr) != 1 {
		t.Fatalf("precondition failed: expected prev=2, curr=1; got prev=%d curr=%d", len(pc.prev), len(pc.curr))
	}

	// Now get(k1): it must be found in prev and promoted into curr (no rotation).
	got, ok := pc.get(k1)
	if !ok || got != p1 {
		t.Fatalf("expected promotion hit for k1 with p1, got ok=%v plan=%p", ok, got)
	}

	// After promotion, curr should contain k1 in addition to k3.
	if _, ok := pc.curr[k1]; !ok {
		t.Fatalf("expected k1 to be promoted into curr")
	}
	if _, ok := pc.curr[k3]; !ok {
		t.Fatalf("expected k3 to remain in curr")
	}

	// We do not require removal from prev (promotion duplicates, consistent with fieldCache).
	if _, ok := pc.prev[k1]; !ok {
		t.Fatalf("expected k1 to still exist in prev (promotion does not delete)")
	}
}

// TestPlanCache_Get_RotatesOnPromotionWhenCurrFull verifies that if curr is full
// at the moment we promote from prev, get() performs a rotation (prev <- curr, curr reset)
// before inserting the promoted entry.
func TestPlanCache_Get_RotatesOnPromotionWhenCurrFull(t *testing.T) {
	pc := newPlanCache(1) // max=1 ensures curr is "full" with a single entry
	pA := &scanPlan{}
	pB := &scanPlan{}

	kA := planKey{dstType: reflect.TypeOf(struct{ A int }{}), sig: "col"}
	kB := planKey{dstType: reflect.TypeOf(struct{ B int }{}), sig: "col"}

	// Put A → curr={A}
	pc.put(kA, pA)
	// Put B → rotation on put: prev={A}, curr={B}
	pc.put(kB, pB)

	// Sanity check preconditions.
	if len(pc.prev) != 1 || len(pc.curr) != 1 {
		t.Fatalf("precondition failed: expected prev=1, curr=1; got prev=%d curr=%d", len(pc.prev), len(pc.curr))
	}
	if _, ok := pc.prev[kA]; !ok {
		t.Fatalf("expected kA in prev before promotion")
	}
	if _, ok := pc.curr[kB]; !ok {
		t.Fatalf("expected kB in curr before promotion")
	}

	// Now promote A from prev while curr is full.
	got, ok := pc.get(kA)
	if !ok || got != pA {
		t.Fatalf("expected promotion of kA with pA, got ok=%v plan=%p", ok, got)
	}

	// Because curr was full at promotion time, get() should have rotated:
	// new prev = old curr ({kB}), new curr = {kA}
	if len(pc.curr) != 1 || len(pc.prev) != 1 {
		t.Fatalf("after promotion-rotation: expected prev=1, curr=1; got prev=%d curr=%d", len(pc.prev), len(pc.curr))
	}
	if _, ok := pc.curr[kA]; !ok {
		t.Fatalf("expected kA to be in curr after rotation")
	}
	if _, ok := pc.prev[kB]; !ok {
		t.Fatalf("expected kB to be in prev after rotation")
	}
}

// TestScanAllRowsLike_WithPlanCache is a small integration test exercising the cached plan
// by scanning two rows into a slice of structs and a slice of *structs.
func TestScanAllRowsLike_WithPlanCache(t *testing.T) {
	type Row struct {
		ID   int    `db:"id"`
		Name string `db:"name"`
	}

	// rowsLike is assumed to be your existing test double with fields:
	//   cols []string
	// and methods:
	//   Next() bool
	//   Scan(...any) error
	//   Err() error
	r1 := &rowsLike{
		cols: []string{"id", "name"},
		// configure your rows data here...
	}
	var out1 []Row
	if err := scanAllRowsLike(r1, &out1); err != nil {
		t.Fatalf("unexpected error scanning into []Row: %v", err)
	}

	r2 := &rowsLike{
		cols: []string{"id", "name"},
		// same data reused to exercise cache hit
	}
	var out2 []*Row
	if err := scanAllRowsLike(r2, &out2); err != nil {
		t.Fatalf("unexpected error scanning into []*Row: %v", err)
	}
}

// TestBind_NestedInterfaceLeafNil_YieldsNilArg_AllDialects verifies that a
// nested interface leaf bound via tag produces a nil argument when the leaf is
// nil, and that placeholder count matches across all dialects.
func TestBind_NestedInterfaceLeafNil_YieldsNilArg_AllDialects(t *testing.T) {
	// Struct with interface leaf mapped via tag, nil at leaf
	type Holder struct {
		V any `db:"val"`
	}
	h := Holder{V: nil}

	for _, dc := range allDialects() {
		ec := &execCatcher{}
		res, err := New(dc.d).
			Write("UPDATE t SET x=:val").
			Bind(h).
			Exec(ec)
		assertNoError(t, err)

		if got := countPH(ec.lastQuery, dc.d); got != 1 {
			t.Fatalf("[%s] ph=%d, want 1; q=%s", dc.name, got, ec.lastQuery)
		}
		if len(ec.lastArgs) != 1 || ec.lastArgs[0] != nil {
			t.Fatalf("[%s] arg[0]=%v, want nil", dc.name, ec.lastArgs)
		}
		if _, err := res.RowsAffected(); err != nil {
			t.Fatalf("[%s] RowsAffected err: %v", dc.name, err)
		}
	}
}

// TestBind_EmbeddedPointerStruct_DerefAndNil_AllDialects ensures that values
// from an anonymously embedded pointer struct are dereferenced for binding when
// non-nil, and produce a nil argument when the embedded pointer is nil.
func TestBind_EmbeddedPointerStruct_DerefAndNil_AllDialects(t *testing.T) {
	type Inner struct {
		A int `db:"a"`
	}
	type Outer struct {
		*Inner // anonymous embedded pointer
	}

	for _, dc := range allDialects() {
		// case 1: non-nil pointer → should extract 7
		out, args, err := New(dc.d).
			Write("SELECT :a").
			Bind(Outer{Inner: &Inner{A: 7}}).
			Build()
		assertNoError(t, err)
		if got := countPlaceholders(out, dc.d); got != 1 {
			t.Fatalf("[%s] placeholders=%d, want 1\nOUT:\n%s", dc.name, got, out)
		}
		assertArgsEqual(t, args, []any{7})

		// case 2: nil pointer → argument should be nil
		out, args, err = New(dc.d).
			Write("SELECT :a").
			Bind(Outer{Inner: nil}).
			Build()
		assertNoError(t, err)
		if got := countPlaceholders(out, dc.d); got != 1 {
			t.Fatalf("[%s] placeholders=%d, want 1\nOUT:\n%s", dc.name, got, out)
		}
		if len(args) != 1 || args[0] != nil {
			t.Fatalf("[%s] arg[0]=%v, want nil", dc.name, args)
		}
	}
}

// rowsLike minimal adapter (no driver/mock allocs) for benchmarks
type rowsLike struct {
	cols []string
	data [][]any
	i    int
}

func (r *rowsLike) Columns() ([]string, error) { return r.cols, nil }
func (r *rowsLike) Next() bool                 { r.i++; return r.i <= len(r.data) }
func (r *rowsLike) Scan(dest ...any) error {
	row := r.data[r.i-1]
	for i := range dest {
		reflect.ValueOf(dest[i]).Elem().Set(reflect.ValueOf(row[i]))
	}
	return nil
}
func (r *rowsLike) Err() error   { return nil }
func (r *rowsLike) Close() error { return nil }

// scanAllRowsLike scans rows from a rows-like test double into dest using the cached scan plan.
// It mirrors the production ScanAll path but works against a test stub (rowsLike).
func scanAllRowsLike(rows *rowsLike, dest any) error {
	rv := reflect.ValueOf(dest)
	if rv.Kind() != reflect.Pointer || rv.IsNil() {
		return fmt.Errorf("scanAllRowsLike: dest must be a non-nil pointer to slice")
	}
	rv = rv.Elem()
	if rv.Kind() != reflect.Slice {
		return fmt.Errorf("scanAllRowsLike: dest must be a pointer to slice")
	}

	if rv.Len() != 0 {
		rv.Set(rv.Slice(0, 0))
	}

	elemT := rv.Type().Elem()
	cols := rows.cols

	switch elemT.Kind() {
	case reflect.Struct, reflect.Pointer:
		isPtr := elemT.Kind() == reflect.Pointer
		var structT reflect.Type
		if isPtr {
			if elemT.Elem().Kind() != reflect.Struct {
				return fmt.Errorf("scanAllRowsLike: slice of pointers to non-struct")
			}
			structT = elemT.Elem()
		} else {
			structT = elemT
		}

		plan, err := getScanPlan(cols, structT)
		if err != nil {
			return err
		}
		st := plan.newState()

		for rows.Next() {
			if isPtr {
				// []*Struct: create *Struct, scan into Elem, then append the pointer
				ptr := reflect.New(structT)
				dst := ptr.Elem()

				for i := range cols {
					switch plan.kinds[i] {
					case ckSink:
						st.targets[i] = st.sinks[i]
					case ckScanner, ckValue:
						fv := fieldByIndexAlloc(dst, plan.fPath[i])
						st.targets[i] = fv.Addr().Interface()
					case ckPtr:
						h := st.holders[i]
						h.Elem().SetZero()
						st.targets[i] = h.Interface()
					}
				}

				if err := rows.Scan(st.targets...); err != nil {
					return err
				}
				for _, i := range plan.ptrIdx {
					setFieldByIndex(dst, plan.fPath[i], st.holders[i].Elem())
				}
				rv.Set(reflect.Append(rv, ptr))
			} else {
				// []Struct: append zero element first, then populate in place
				rv.Set(reflect.Append(rv, reflect.Zero(structT)))
				dst := rv.Index(rv.Len() - 1)

				for i := range cols {
					switch plan.kinds[i] {
					case ckSink:
						st.targets[i] = st.sinks[i]
					case ckScanner, ckValue:
						fv := fieldByIndexAlloc(dst, plan.fPath[i])
						st.targets[i] = fv.Addr().Interface()
					case ckPtr:
						h := st.holders[i]
						h.Elem().SetZero()
						st.targets[i] = h.Interface()
					}
				}

				if err := rows.Scan(st.targets...); err != nil {
					return err
				}
				for _, i := range plan.ptrIdx {
					setFieldByIndex(dst, plan.fPath[i], st.holders[i].Elem())
				}
			}
		}
		return rows.Err()

	default:
		// Primitive/Scanner → must be 1 column
		if len(cols) != 1 {
			return fmt.Errorf("scanAllRowsLike: non-struct slice requires exactly 1 column, got %d", len(cols))
		}
		for rows.Next() {
			item := reflect.New(elemT).Elem()
			if err := rows.Scan(item.Addr().Interface()); err != nil {
				return err
			}
			rv.Set(reflect.Append(rv, item))
		}
		return rows.Err()
	}
}

// BenchmarkMapper_MapOnly_Struct_1k measures the overhead of mapping 1,000
// rows into structs using the scan plan and without involving a real DB driver.
func BenchmarkMapper_MapOnly_Struct_1k(b *testing.B) {
	type Row struct {
		ID   int    `db:"id"`
		Name string `db:"name"`
		Ok   bool   `db:"ok"`
	}
	cols := []string{"id", "name", "ok"}
	data := make([][]any, 1000)
	for i := 0; i < 1000; i++ {
		data[i] = []any{i, "name", i%2 == 0}
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		var out []Row
		rows := &rowsLike{cols: cols, data: data}
		if err := scanAllRowsLike(rows, &out); err != nil {
			b.Fatal(err)
		}
		if len(out) != 1000 {
			b.Fatal("len != 1000")
		}
	}
}

// BenchmarkMapper_MapOnly_Primitive_1k measures mapping cost for 1,000
// primitive values (single column) into a slice of ints.
func BenchmarkMapper_MapOnly_Primitive_1k(b *testing.B) {
	cols := []string{"v"}
	data := make([][]any, 1000)
	for i := 0; i < 1000; i++ {
		data[i] = []any{i}
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		var out []int
		rows := &rowsLike{cols: cols, data: data}
		if err := scanAllRowsLike(rows, &out); err != nil {
			b.Fatal(err)
		}
		if len(out) != 1000 {
			b.Fatal("len != 1000")
		}
	}
}

func scanOneStructRowsLike(rows *rowsLike, dest any) error {
	rv := reflect.ValueOf(dest)
	if rv.Kind() != reflect.Pointer || rv.IsNil() {
		return fmt.Errorf("dest must be a non-nil pointer")
	}
	rv = rv.Elem()
	if rv.Kind() != reflect.Struct {
		return fmt.Errorf("dest must be a pointer to struct")
	}

	cols := rows.cols
	fmap := fieldIndexMap(rv.Type()) // column name -> fieldInfo (with path []int)

	targets := make([]any, len(cols))
	sinks := make([]any, len(cols))
	var post []func()

	for i, c := range cols {
		if fi, ok := fmap[c]; ok {
			// leaf type
			sf := rv.Type().FieldByIndex(fi.index)
			ft := sf.Type

			// field implements sql.Scanner?
			if reflect.PointerTo(ft).Implements(scannerIface) {
				fv := fieldByIndexAlloc(rv, fi.index)
				targets[i] = fv.Addr().Interface()
				continue
			}

			// *T field -> use **T and copy post-scan
			if ft.Kind() == reflect.Pointer {
				holder := reflect.New(ft) // **T
				targets[i] = holder.Interface()
				path := append([]int(nil), fi.index...) // capture a copy of the path
				post = append(post, func() {
					setFieldByIndex(rv, path, holder.Elem())
				})
				continue
			}

			// value field: allocate intermediates along the path
			fv := fieldByIndexAlloc(rv, fi.index)
			targets[i] = fv.Addr().Interface()
		} else {
			// unmapped column -> sink
			targets[i] = &sinks[i]
		}
	}

	if !rows.Next() {
		return fmt.Errorf("no rows")
	}
	if err := rows.Scan(targets...); err != nil {
		return err
	}
	for _, f := range post {
		f()
	}
	return nil
}

// benchRow is a representative struct used in single-row struct mapping benchmarks.
type benchRow struct {
	A int    `db:"a"`
	B string `db:"b"`
	C int64  `db:"c"`
	D bool   `db:"d"`
	E string `db:"e"`
}

// BenchmarkMapper_Scan_OneRow_Struct_MapOnly measures allocations and runtime
// for scanning a single row into a struct using the lightweight rowsLike.
func BenchmarkMapper_Scan_OneRow_Struct_MapOnly(b *testing.B) {
	cols := []string{"a", "b", "c", "d", "e"}
	data := [][]any{{7, "name", int64(42), true, "note"}}

	b.ReportAllocs()
	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		var out benchRow
		rows := &rowsLike{cols: cols, data: data}
		if err := scanOneStructRowsLike(rows, &out); err != nil {
			b.Fatal(err)
		}
	}
}

type benchResult struct{ id, rows int64 }

func (r benchResult) LastInsertId() (int64, error) { return r.id, nil }
func (r benchResult) RowsAffected() (int64, error) { return r.rows, nil }

type benchExecer struct{}

func (benchExecer) ExecContext(_ context.Context, _ string, _ ...any) (sql.Result, error) {
	return benchResult{id: 123, rows: 3}, nil
}

// BenchmarkMapper_Exec_BuildAndExec_MapOnly measures the cost of building a
// query with named params, binding, and executing via a stub execer.
func BenchmarkMapper_Exec_BuildAndExec_MapOnly(b *testing.B) {
	ex := benchExecer{}
	s := New(Postgres)

	b.ReportAllocs()
	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		res, err := s.Write("UPDATE t SET x=:x WHERE id IN (:ids)").
			Bind(P{"x": i, "ids": []int{i, i + 1, i + 2}}).
			Exec(ex)
		if err != nil {
			b.Fatal(err)
		}
		if _, err := res.RowsAffected(); err != nil {
			b.Fatal(err)
		}
	}
}