fix(diff): cast daterange and rerun row fetches to text so repairs work

IsKnownScalarType matched format_type names by prefix, so "daterange"
passed as "date" and was the one complex type still fetched un-cast --
its Go-struct form in the diff report failed the whole upsert batch on
repair (malformed range literal). Strip the typmod and require an exact
match, which also covers datemultirange and UDTs sharing a scalar's
prefix.

table-rerun's row fetch never applied the cast policy at all; it now
consults the same NeedsTextCast so rerun reports stay repairable.

The typed-columns integration test gains a daterange column and a rerun
leg; the cast-policy decision table covers the collision cases.

Author: mason-sharp

internal/consistency/diff/table_rerun.go

@@ -276,10 +276,22 @@ func fetchRowsByPkeys(ctx context.Context, pool *pgxpool.Pool, t *TableDiffTask,
 		joinConditions = append(joinConditions, fmt.Sprintf("t.%s = temp.%s", sanitisedPkCol, sanitisedPkCol))
 	}
 
+	colTypes, err := queries.GetColumnTypes(ctx, tx, t.Schema, t.Table)
+	if err != nil {
+		return nil, fmt.Errorf("could not determine column types: %w", err)
+	}
+
 	selectCols := make([]string, 0, len(t.Cols)+2)
 	selectCols = append(selectCols, "pg_xact_commit_timestamp(t.xmin) as commit_ts", "to_json(pg_xact_commit_timestamp_origin(t.xmin))->>'roident' as node_origin")
 	for _, col := range t.Cols {
-		selectCols = append(selectCols, "t."+pgx.Identifier{col}.Sanitize())
+		quotedCol := pgx.Identifier{col}.Sanitize()
+		// Same cast policy as the diff engines' row fetches: complex types
+		// must travel as Postgres text so the rerun report stays repairable.
+		if utils.NeedsTextCast(colTypes[col]) {
+			selectCols = append(selectCols, fmt.Sprintf("t.%s::TEXT AS %s", quotedCol, quotedCol))
+		} else {
+			selectCols = append(selectCols, "t."+quotedCol)
+		}
 	}
 
 	fetchSQL := fmt.Sprintf("SELECT %s FROM %s t JOIN %s temp ON %s",

pkg/common/utils.go

@@ -1003,37 +1003,52 @@ func SafeCut(s string, n int) string {
 // conversion code. Both diff engines must build their row-fetch SELECTs with
 // it so reports stay engine-independent and repairable.
 func SelectColExpr(quotedCol, colType string) string {
-	if strings.HasSuffix(colType, "[]") ||
-		strings.Contains(strings.ToLower(colType), "json") ||
-		strings.Contains(strings.ToLower(colType), "bytea") ||
-		!IsKnownScalarType(colType) {
+	if NeedsTextCast(colType) {
 		return fmt.Sprintf("%s::TEXT AS %s", quotedCol, quotedCol)
 	}
 	return quotedCol
 }
 
+// NeedsTextCast reports whether a diff row fetch must cast the column to
+// ::TEXT for its value to round-trip through a diff report (see
+// SelectColExpr). Row-fetch sites that cannot use SelectColExpr verbatim
+// (e.g. table-qualified selects) must still consult this policy.
+func NeedsTextCast(colType string) bool {
+	return strings.HasSuffix(colType, "[]") ||
+		strings.Contains(strings.ToLower(colType), "json") ||
+		strings.Contains(strings.ToLower(colType), "bytea") ||
+		!IsKnownScalarType(colType)
+}
+
 func IsKnownScalarType(colType string) bool {
-	// "time with time zone" (timetz) is NOT registered in the pgx v5
-	// default type map, so it cannot be scanned into *interface{}. Exclude it
-	// so the diff layer casts it to ::TEXT.
-	if strings.HasPrefix(colType, "time with time zone") {
-		return false
+	// colType is pg_catalog.format_type output. Strip the typmod so
+	// "numeric(10,2)" and "timestamp(3) with time zone" match their base
+	// names, then require an exact match: prefix matching mistook types that
+	// merely start like a scalar ("daterange" for "date") for the scalar
+	// itself, so they were never cast to ::TEXT and reached diff reports as
+	// unrepairable Go-formatted structs.
+	base := colType
+	if i := strings.IndexByte(base, '('); i >= 0 {
+		if j := strings.IndexByte(base[i:], ')'); j >= 0 {
+			base = strings.TrimSpace(base[:i] + base[i+j+1:])
+		}
 	}
 
-	knownPrefixes := []string{
-		"character", "text",
+	switch base {
+	case "character varying", "character", "text",
 		"integer", "bigint", "smallint",
 		"numeric", "decimal", "real", "double precision",
 		"boolean",
 		"bytea",
 		"json", "jsonb",
 		"uuid",
-		"timestamp", "date", "time",
-	}
-	for _, prefix := range knownPrefixes {
-		if strings.HasPrefix(colType, prefix) {
-			return true
-		}
+		"date",
+		"timestamp without time zone", "timestamp with time zone",
+		// "time with time zone" (timetz) is deliberately absent: it is not
+		// registered in the pgx v5 default type map, so it cannot be scanned
+		// into *interface{} and must be cast to ::TEXT by the diff layer.
+		"time without time zone":
+		return true
 	}
 	return false
 }

pkg/common/utils_test.go

@@ -132,12 +132,20 @@ func TestSelectColExpr(t *testing.T) {
 	}{
 		{"integer", `"c"`},
 		{"timestamp without time zone", `"c"`},
+		{"timestamp(3) with time zone", `"c"`},
+		{"numeric(10,2)", `"c"`},
+		{"date", `"c"`},
 		{"uuid", `"c"`},
 		{"integer[]", `"c"::TEXT AS "c"`},
 		{"jsonb", `"c"::TEXT AS "c"`},
 		{"bytea", `"c"::TEXT AS "c"`},
 		{"point", `"c"::TEXT AS "c"`},
 		{"int4range", `"c"::TEXT AS "c"`},
+		// "daterange" must not be mistaken for "date" (nor "datemultirange",
+		// nor a UDT that happens to share a scalar's name as a prefix).
+		{"daterange", `"c"::TEXT AS "c"`},
+		{"datemultirange", `"c"::TEXT AS "c"`},
+		{"date_status_enum", `"c"::TEXT AS "c"`},
 		{"mood_enum", `"c"::TEXT AS "c"`},
 		{"xml", `"c"::TEXT AS "c"`},
 		{"bit(8)", `"c"::TEXT AS "c"`},

tests/integration/mtree_typed_repair_test.go

@@ -21,18 +21,20 @@ import (
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"github.com/stretchr/testify/require"
+
+	"github.com/pgedge/ace/internal/consistency/diff"
 )
 
 // typedRepairDDL covers the type classes repair must round-trip: temporal,
 // money, uuid, interval, numeric, plus the complex ones the driver scans as
 // opaque structs (geometric, range, bit, network, enum, xml).
 const typedRepairDDL = ` (id BIGINT PRIMARY KEY, name VARCHAR(100), col_time TIME, col_timetz TIMETZ,
 	col_money MONEY, col_uuid UUID, col_interval INTERVAL, col_num NUMERIC(12,4),
-	col_point POINT, col_range INT4RANGE, col_bit BIT(8), col_inet INET,
-	col_xml XML, col_mood typed_repair_mood)`
+	col_point POINT, col_range INT4RANGE, col_daterange DATERANGE, col_bit BIT(8),
+	col_inet INET, col_xml XML, col_mood typed_repair_mood)`
 
 const typedRepairSeedSQL = ` (id, name, col_time, col_timetz, col_money, col_uuid, col_interval, col_num,
-		col_point, col_range, col_bit, col_inet, col_xml, col_mood)
+		col_point, col_range, col_daterange, col_bit, col_inet, col_xml, col_mood)
 	SELECT i,
 	       'name_' || i,
 	       TIME '00:00:00' + (i * 137 || ' seconds')::interval,
@@ -43,6 +45,7 @@ const typedRepairSeedSQL = ` (id, name, col_time, col_timetz, col_money, col_uui
 	       i * 1.5,
 	       point(i, i * 2),
 	       int4range(i, i + 100),
+	       daterange(DATE '2020-01-01' + i, DATE '2020-01-01' + i + 30),
 	       (i % 256)::bit(8),
 	       ('10.0.' || (i % 256) || '.' || (i % 200 + 1))::inet,
 	       ('<item id="' || i || '"><name>item_' || i || '</name></item>')::xml,
@@ -148,4 +151,20 @@ func TestMtreeDiffRepairTypedColumns(t *testing.T) {
 
 	require.Equal(t, typedRepairFingerprint(t, ctx, env.N1Pool, safe), typedRepairFingerprint(t, ctx, env.N2Pool, safe),
 		"nodes must hold identical rows (all typed columns included) after repair")
+
+	// table-rerun re-fetches the diffed rows by primary key -- a separate
+	// SELECT that must apply the same ::TEXT cast policy, or typed columns
+	// fail the scan (timetz) or re-compare as spurious diffs. On the now
+	// converged nodes it must succeed and confirm every diff resolved.
+	rerunTask := diff.NewTableDiffTask()
+	rerunTask.Mode = "rerun"
+	rerunTask.ClusterName = env.ClusterName
+	rerunTask.DBName = env.DBName
+	rerunTask.DiffFilePath = diffFile
+	rerunTask.Ctx = ctx
+	require.NoError(t, rerunTask.ExecuteTask(), "table-rerun must succeed on typed columns")
+
+	rerunReports, err := filepath.Glob(fmt.Sprintf("%s_%s_rerun-diffs-*.json", testSchema, tableName))
+	require.NoError(t, err)
+	require.Empty(t, rerunReports, "rerun on converged nodes must not report persistent diffs")
 }