dumpling/export: fail loudly on boundary-sampling errors and unknown column types

- Boundary-sampling failure used to log a warning and `break`, which
  silently dropped into the post-loop branches. On a first-iteration
  failure the table was dumped as a single un-chunked task; on a later
  failure the dump emitted an oversized "tail" chunk from the last
  good boundary to +∞. Either way the caller never saw the failure.
  Return the error so the job-level retry/backoff applies.
- Replace the silent `fmt.Sprintf("%v", v)` fallback in the row-scan
  type switch with an explicit error referencing the column name and
  Go type. The MySQL driver returns string/[]byte/int*/float* for the
  supported boundary types (parseTime is not enabled in
  GetDriverConfig), so any other type means a future caller widened
  the chunking surface beyond what the WHERE-clause builders support
  and we should fail loudly rather than emit a malformed predicate.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: takaidohigasi

dumpling/export/string_chunking.go

@@ -175,26 +175,33 @@ func (d *Dumper) streamStringChunks(tctx *tcontext.Context, conn *BaseConn, meta
 			for j, val := range values {
 				if val == nil {
 					currentBoundary[j] = ""
-				} else {
-					// Convert SQL driver value to string properly
-					switch v := val.(type) {
-					case string:
-						currentBoundary[j] = v
-					case []byte:
-						currentBoundary[j] = string(v)
-					case int64:
-						currentBoundary[j] = strconv.FormatInt(v, 10)
-					case int32:
-						currentBoundary[j] = strconv.FormatInt(int64(v), 10)
-					case int:
-						currentBoundary[j] = strconv.Itoa(v)
-					case float64:
-						currentBoundary[j] = strconv.FormatFloat(v, 'f', -1, 64)
-					case float32:
-						currentBoundary[j] = strconv.FormatFloat(float64(v), 'f', -1, 32)
-					default:
-						currentBoundary[j] = fmt.Sprintf("%v", v)
-					}
+					continue
+				}
+				// Supported driver-returned types for boundary columns. The
+				// MySQL driver returns []byte for string/binary/DECIMAL/DATE*
+				// (parseTime is not enabled, see GetDriverConfig), int64 for
+				// integers, and float64 for floating-point — all of which
+				// round-trip safely through the WHERE-clause builders. Any
+				// other type would silently produce a malformed predicate, so
+				// fail loudly instead.
+				switch v := val.(type) {
+				case string:
+					currentBoundary[j] = v
+				case []byte:
+					currentBoundary[j] = string(v)
+				case int64:
+					currentBoundary[j] = strconv.FormatInt(v, 10)
+				case int32:
+					currentBoundary[j] = strconv.FormatInt(int64(v), 10)
+				case int:
+					currentBoundary[j] = strconv.Itoa(v)
+				case float64:
+					currentBoundary[j] = strconv.FormatFloat(v, 'f', -1, 64)
+				case float32:
+					currentBoundary[j] = strconv.FormatFloat(float64(v), 'f', -1, 32)
+				default:
+					return fmt.Errorf("unsupported boundary column type %T for %s in table `%s`.`%s`",
+						v, orderByColumns[j], db, tbl)
 				}
 			}
 			return nil
@@ -207,12 +214,19 @@ func (d *Dumper) streamStringChunks(tctx *tcontext.Context, conn *BaseConn, meta
 		}, sampleQuery)
 
 		if err != nil {
-			tctx.L().Warn("failed to sample boundary, stopping boundary collection",
+			// Don't swallow sampling failures: with `break` the loop would fall
+			// through to the post-loop branches and either dump the entire table
+			// as one un-chunked task (when the very first sample fails) or emit
+			// an oversized tail chunk from the last good boundary to +∞ (when a
+			// later sample fails). Both silently degrade the dump. Propagate so
+			// the job-level retry/backoff applies and the caller sees the
+			// failure.
+			tctx.L().Warn("failed to sample boundary, aborting string-key chunking",
 				zap.String("database", db),
 				zap.String("table", tbl),
 				zap.Int64("chunkIndex", i),
 				zap.Error(err))
-			break
+			return err
 		}
 
 		if len(currentBoundary) == 0 {