From 0e7bb965913a269228356470b248d5a21802d9dd Mon Sep 17 00:00:00 2001
From: Svetlin Ralchev <iamralch@users.noreply.github.com>
Date: Wed, 23 Sep 2026 10:16:57 +0400
Subject: [PATCH] fix: implement pgx.Rows TypeMap for pgx v5.11

pgx v5.11.0 added TypeMap() to the pgx.Rows interface, so Rows,
RowsRecorder and RowsError no longer satisfied it and the package failed
to compile.

- Rows returns the registry it already scans cached rows with.
- RowsRecorder delegates to the wrapped rows.
- RowsError returns nil, which pgx documents as valid for a Rows that
  carries only an error.
---
 querier.go      | 15 +++++++++++++++
 querier_test.go | 29 +++++++++++++++++++++++++++++
 2 files changed, 44 insertions(+)

diff --git a/querier.go b/querier.go
index 3eb1c2b..88fed63 100644
--- a/querier.go
+++ b/querier.go
@@ -550,6 +550,11 @@ func (r *Rows) RawValues() [][]byte {
 	return r.item.Rows[r.index]
 }
 
+// TypeMap implements pgx.Rows.
+func (r *Rows) TypeMap() *pgtype.Map {
+	return r.registry
+}
+
 var _ pgx.Rows = &RowsRecorder{}
 
 // RowsRecorder is a wrapper around pgx.Rows that records the rows.
@@ -637,6 +642,11 @@ func (r *RowsRecorder) Values() ([]any, error) {
 	return r.rows.Values()
 }
 
+// TypeMap implements pgx.Rows.
+func (r *RowsRecorder) TypeMap() *pgtype.Map {
+	return r.rows.TypeMap()
+}
+
 var _ pgx.Rows = &RowsError{}
 
 // RowsError is a wrapper around pgx.Rows that returns an error.
@@ -687,6 +697,11 @@ func (r *RowsError) Values() ([]any, error) {
 	return nil, r.err
 }
 
+// TypeMap implements pgx.Rows.
+func (r *RowsError) TypeMap() *pgtype.Map {
+	return nil
+}
+
 var _ pgx.BatchResults = &BatchQuerier{}
 
 // BatchQuerier is a wrapper around pgx.BatchResults that records the batch results.
diff --git a/querier_test.go b/querier_test.go
index 801ac84..86c3d71 100644
--- a/querier_test.go
+++ b/querier_test.go
@@ -31,6 +31,7 @@ type MockRows struct {
 	ValuesFn            func() ([]any, error)
 	RawValuesFn         func() [][]byte
 	ConnFn              func() *pgx.Conn
+	TypeMapFn           func() *pgtype.Map
 }
 
 func (m *MockRows) Close() {
@@ -95,6 +96,13 @@ func (m *MockRows) Conn() *pgx.Conn {
 	return nil
 }
 
+func (m *MockRows) TypeMap() *pgtype.Map {
+	if m.TypeMapFn != nil {
+		return m.TypeMapFn()
+	}
+	return nil
+}
+
 var _ pgx.BatchResults = &MockBatchResults{}
 
 type MockBatchResults struct {
@@ -467,6 +475,10 @@ var _ = Describe("Rows", func() {
 	It("Err returns nil", func() {
 		Expect(rows.Err()).To(BeNil())
 	})
+
+	It("TypeMap returns the registry", func() {
+		Expect(rows.TypeMap()).To(BeIdenticalTo(rows.registry))
+	})
 })
 
 var _ = Describe("RowError", func() {
@@ -521,6 +533,10 @@ var _ = Describe("RowsError", func() {
 	It("Close does nothing", func() {
 		Expect(func() { re.Close() }).NotTo(Panic())
 	})
+
+	It("TypeMap returns nil", func() {
+		Expect(re.TypeMap()).To(BeNil())
+	})
 })
 
 var _ = Describe("RowScanner", func() {
@@ -615,6 +631,19 @@ var _ = Describe("RowsRecorder", func() {
 		}
 		Expect(recorder.Err()).To(Equal(sentinel))
 	})
+
+	It("TypeMap delegates to underlying rows", func() {
+		registry := pgtype.NewMap()
+		mockRows := &MockRows{
+			TypeMapFn: func() *pgtype.Map { return registry },
+		}
+		recorder := &RowsRecorder{
+			rows:  mockRows,
+			item:  &QueryItem{},
+			cache: func(i *QueryItem) error { return nil },
+		}
+		Expect(recorder.TypeMap()).To(BeIdenticalTo(registry))
+	})
 })
 
 var _ = Describe("RowRecorder", func() {