runtime/vam: return error on cast of invalid UTF-8 bytes to string (#6273)

nwt · web-flow · commit 4586c71bf2d4 · 2025-10-02T15:23:04.000-04:00
The sequential runtime returns a structured error when a bytes value
containing invalid UTF-8 is cast to a string.  Do the same in the
vector runtime.

The change in runtime/vam/expr/cast.castToString implements the new
behavior.  The remaining changes just add a msgSuffix parameter to
errCastFailed so castToString can produce the same error message as the
sequential runtime.

There are some possible optimizations here but they can wait until
castToString appears in CPU profiles.

The test coverage added in runtime/ztests/expr/cast/string.yaml
duplicates runtime/sam/expr/ztests/cast-bytes-string-err.yaml, so remove
the latter file.
diff --git a/runtime/sam/expr/ztests/cast-bytes-string-err.yaml b/runtime/sam/expr/ztests/cast-bytes-string-err.yaml
diff --git a/runtime/vam/expr/cast/bool.go b/runtime/vam/expr/cast/bool.go
@@ -6,7 +6,7 @@ import (
 	"github.com/brimdata/super/vector/bitvec"
 )
 
-func castToBool(vec vector.Any, index []uint32) (vector.Any, []uint32, bool) {
+func castToBool(vec vector.Any, index []uint32) (vector.Any, []uint32, string, bool) {
 	var out *vector.Bool
 	switch vec := vec.(type) {
 	case *vector.Int:
@@ -17,17 +17,17 @@ func castToBool(vec vector.Any, index []uint32) (vector.Any, []uint32, bool) {
 		out = numberToBool(vec.Values, index)
 	case *vector.String:
 		vvec, errs := stringToBool(vec, index)
-		return vvec, errs, true
+		return vvec, errs, "", true
 	default:
-		return nil, nil, false
+		return nil, nil, "", false
 	}
 	nulls := vector.NullsOf(vec)
 	if index == nil {
 		out.Nulls = nulls
 	} else {
 		out.Nulls = nulls.Pick(index)
 	}
-	return out, nil, true
+	return out, nil, "", true
 }
 
 func numberToBool[E numeric](s []E, index []uint32) *vector.Bool {
diff --git a/runtime/vam/expr/cast/bytes.go b/runtime/vam/expr/cast/bytes.go
@@ -4,14 +4,14 @@ import (
 	"github.com/brimdata/super/vector"
 )
 
-func castToBytes(vec vector.Any, index []uint32) (vector.Any, []uint32, bool) {
+func castToBytes(vec vector.Any, index []uint32) (vector.Any, []uint32, string, bool) {
 	strVec, ok := vec.(*vector.String)
 	if !ok {
-		return nil, nil, false
+		return nil, nil, "", false
 	}
 	out := vector.Any(vector.NewBytes(strVec.Table(), vector.NullsOf(strVec)))
 	if index != nil {
 		out = vector.Pick(out, index)
 	}
-	return out, nil, true
+	return out, nil, "", true
 }
diff --git a/runtime/vam/expr/cast/cast.go b/runtime/vam/expr/cast/cast.go
@@ -13,7 +13,7 @@ func To(sctx *super.Context, vec vector.Any, typ super.Type) vector.Any {
 	var c caster
 	id := typ.ID()
 	if super.IsNumber(id) {
-		c = func(vec vector.Any, index []uint32) (vector.Any, []uint32, bool) {
+		c = func(vec vector.Any, index []uint32) (vector.Any, []uint32, string, bool) {
 			return castToNumber(vec, typ, index)
 		}
 	} else {
@@ -29,29 +29,30 @@ func To(sctx *super.Context, vec vector.Any, typ super.Type) vector.Any {
 		case super.IDNet:
 			c = castToNet
 		case super.IDType:
-			c = func(vec vector.Any, index []uint32) (vector.Any, []uint32, bool) {
+			c = func(vec vector.Any, index []uint32) (vector.Any, []uint32, string, bool) {
 				return castToType(sctx, vec, index)
 			}
 		default:
-			return errCastFailed(sctx, vec, typ)
+			return errCastFailed(sctx, vec, typ, "")
 		}
 	}
 	return assemble(sctx, vec, typ, c)
 }
 
-type caster func(vector.Any, []uint32) (vector.Any, []uint32, bool)
+type caster func(vector.Any, []uint32) (vector.Any, []uint32, string, bool)
 
 func assemble(sctx *super.Context, vec vector.Any, typ super.Type, fn caster) vector.Any {
 	var out vector.Any
 	var errs []uint32
+	var errMsg string
 	var ok bool
 	switch vec := vec.(type) {
 	case *vector.Const:
 		return castConst(sctx, vec, typ)
 	case *vector.View:
-		out, errs, ok = fn(vec.Any, vec.Index)
+		out, errs, errMsg, ok = fn(vec.Any, vec.Index)
 	case *vector.Dict:
-		out, errs, ok = fn(vec.Any, nil)
+		out, errs, errMsg, ok = fn(vec.Any, nil)
 		if ok {
 			if len(errs) > 0 {
 				index, counts, nulls, nerrs := vec.RebuildDropTags(errs...)
@@ -62,13 +63,13 @@ func assemble(sctx *super.Context, vec vector.Any, typ super.Type, fn caster) ve
 			}
 		}
 	default:
-		out, errs, ok = fn(vec, nil)
+		out, errs, errMsg, ok = fn(vec, nil)
 	}
 	if !ok {
-		return errCastFailed(sctx, vec, typ)
+		return errCastFailed(sctx, vec, typ, errMsg)
 	}
 	if len(errs) > 0 {
-		return vector.Combine(out, errs, errCastFailed(sctx, vector.Pick(vec, errs), typ))
+		return vector.Combine(out, errs, errCastFailed(sctx, vector.Pick(vec, errs), typ, errMsg))
 	}
 	return out
 }
@@ -88,17 +89,21 @@ func castConst(sctx *super.Context, vec *vector.Const, typ super.Type) vector.An
 					trueCount++
 				}
 			}
-			err := errCastFailed(sctx, vector.NewConst(vec.Value(), vec.Len()-trueCount, bitvec.Zero), typ)
+			err := errCastFailed(sctx, vector.NewConst(vec.Value(), vec.Len()-trueCount, bitvec.Zero), typ, "")
 			nulls := vector.NewConst(super.NewValue(typ, nil), trueCount, bitvec.Zero)
 			return vector.NewDynamic(index, []vector.Any{err, nulls})
 		}
-		return errCastFailed(sctx, vec, typ)
+		return errCastFailed(sctx, vec, typ, "")
 	}
 	return vector.NewConst(val, vec.Len(), vec.Nulls)
 }
 
-func errCastFailed(sctx *super.Context, vec vector.Any, typ super.Type) vector.Any {
-	return vector.NewWrappedError(sctx, "cannot cast to "+sup.FormatType(typ), vec)
+func errCastFailed(sctx *super.Context, vec vector.Any, typ super.Type, msgSuffix string) vector.Any {
+	msg := "cannot cast to " + sup.FormatType(typ)
+	if msgSuffix != "" {
+		msg = msg + ": " + msgSuffix
+	}
+	return vector.NewWrappedError(sctx, msg, vec)
 }
 
 func lengthOf(vec vector.Any, index []uint32) uint32 {
diff --git a/runtime/vam/expr/cast/ip.go b/runtime/vam/expr/cast/ip.go
@@ -8,10 +8,10 @@ import (
 	"github.com/brimdata/super/vector/bitvec"
 )
 
-func castToIP(vec vector.Any, index []uint32) (vector.Any, []uint32, bool) {
+func castToIP(vec vector.Any, index []uint32) (vector.Any, []uint32, string, bool) {
 	switch vec := vec.(type) {
 	case *vector.IP:
-		return vec, nil, true
+		return vec, nil, "", true
 	case *vector.String:
 		n := lengthOf(vec, index)
 		var nulls bitvec.Bits
@@ -37,16 +37,16 @@ func castToIP(vec vector.Any, index []uint32) (vector.Any, []uint32, bool) {
 			}
 			ips = append(ips, ip)
 		}
-		return vector.NewIP(ips, nulls), errs, true
+		return vector.NewIP(ips, nulls), errs, "", true
 	default:
-		return nil, nil, false
+		return nil, nil, "", false
 	}
 }
 
-func castToNet(vec vector.Any, index []uint32) (vector.Any, []uint32, bool) {
+func castToNet(vec vector.Any, index []uint32) (vector.Any, []uint32, string, bool) {
 	switch vec := vec.(type) {
 	case *vector.Net:
-		return vec, nil, true
+		return vec, nil, "", true
 	case *vector.String:
 		n := lengthOf(vec, index)
 		var nulls bitvec.Bits
@@ -72,8 +72,8 @@ func castToNet(vec vector.Any, index []uint32) (vector.Any, []uint32, bool) {
 			}
 			nets = append(nets, net)
 		}
-		return vector.NewNet(nets, nulls), errs, true
+		return vector.NewNet(nets, nulls), errs, "", true
 	default:
-		return nil, nil, false
+		return nil, nil, "", false
 	}
 }
diff --git a/runtime/vam/expr/cast/number.go b/runtime/vam/expr/cast/number.go
@@ -17,10 +17,10 @@ type numeric interface {
 	constraints.Float | constraints.Integer
 }
 
-func castToNumber(vec vector.Any, typ super.Type, index []uint32) (vector.Any, []uint32, bool) {
+func castToNumber(vec vector.Any, typ super.Type, index []uint32) (vector.Any, []uint32, string, bool) {
 	if vec.Type().ID() == super.IDString {
 		out, errs := castStringToNumber(vec, typ, index)
-		return out, errs, true
+		return out, errs, "", true
 	}
 	nulls := vector.NullsOf(vec)
 	if index != nil {
@@ -32,21 +32,21 @@ func castToNumber(vec vector.Any, typ super.Type, index []uint32) (vector.Any, [
 		if len(errs) > 0 {
 			nulls = nulls.Pick(inverseIndex(errs, nulls.Len()))
 		}
-		return vector.NewInt(typ, vals, nulls), errs, true
+		return vector.NewInt(typ, vals, nulls), errs, "", true
 	case super.IsUnsigned(id):
 		vals, errs := toNumeric[uint64](vec, typ, index)
 		if len(errs) > 0 {
 			nulls = nulls.Pick(inverseIndex(errs, nulls.Len()))
 		}
-		return vector.NewUint(typ, vals, nulls), errs, true
+		return vector.NewUint(typ, vals, nulls), errs, "", true
 	case super.IsFloat(id):
 		vals, errs := toNumeric[float64](vec, typ, index)
 		if errs != nil {
 			nulls = nulls.Pick(inverseIndex(errs, nulls.Len()))
 		}
-		return vector.NewFloat(typ, vals, nulls), errs, true
+		return vector.NewFloat(typ, vals, nulls), errs, "", true
 	default:
-		return nil, nil, false
+		return nil, nil, "", false
 	}
 }
 
diff --git a/runtime/vam/expr/cast/string.go b/runtime/vam/expr/cast/string.go
@@ -3,6 +3,7 @@ package cast
 import (
 	"strconv"
 	"time"
+	"unicode/utf8"
 
 	"github.com/brimdata/super"
 	"github.com/brimdata/super/pkg/nano"
@@ -11,7 +12,7 @@ import (
 	"github.com/brimdata/super/vector"
 )
 
-func castToString(vec vector.Any, index []uint32) (vector.Any, []uint32, bool) {
+func castToString(vec vector.Any, index []uint32) (vector.Any, []uint32, string, bool) {
 	nulls := vector.NullsOf(vec)
 	if index != nil {
 		nulls = nulls.Pick(index)
@@ -56,21 +57,35 @@ func castToString(vec vector.Any, index []uint32) (vector.Any, []uint32, bool) {
 		}
 	case *vector.String:
 		if index == nil {
-			return vec, nil, true
+			return vec, nil, "", true
 		}
 		for _, idx := range index {
 			bytes = append(bytes, vec.Value(idx)...)
 			offs = append(offs, uint32(len(bytes)))
 		}
 	case *vector.Bytes:
+		var errs []uint32
 		for i := range n {
 			idx := i
 			if index != nil {
 				idx = index[i]
 			}
-			bytes = append(bytes, vec.Value(idx)...)
-			offs = append(offs, uint32(len(bytes)))
+			if !utf8.Valid(vec.Value(idx)) {
+				errs = append(errs, i)
+			}
+		}
+		const errMsg = "invalid UTF-8"
+		if len(errs) == int(n) {
+			return nil, nil, errMsg, false
+		}
+		out := vector.Any(vector.NewString(vec.Table(), vec.Nulls))
+		if index != nil {
+			out = vector.Pick(out, index)
+		}
+		if len(errs) > 0 {
+			out = vector.ReversePick(out, errs)
 		}
+		return out, errs, errMsg, true
 	case *vector.IP:
 		for i := range n {
 			idx := i
@@ -115,7 +130,7 @@ func castToString(vec vector.Any, index []uint32) (vector.Any, []uint32, bool) {
 			offs = append(offs, uint32(len(bytes)))
 		}
 	}
-	return vector.NewString(vector.NewBytesTable(offs, bytes), nulls), nil, true
+	return vector.NewString(vector.NewBytesTable(offs, bytes), nulls), nil, "", true
 }
 
 func timeToString(vec *vector.Int, index []uint32, n uint32) ([]uint32, []byte) {
diff --git a/runtime/vam/expr/cast/type.go b/runtime/vam/expr/cast/type.go
@@ -7,10 +7,10 @@ import (
 	"github.com/brimdata/super/vector/bitvec"
 )
 
-func castToType(sctx *super.Context, vec vector.Any, index []uint32) (vector.Any, []uint32, bool) {
+func castToType(sctx *super.Context, vec vector.Any, index []uint32) (vector.Any, []uint32, string, bool) {
 	switch vec := vec.(type) {
 	case *vector.TypeValue:
-		return vec, nil, true
+		return vec, nil, "", true
 	case *vector.String:
 		n := lengthOf(vec, index)
 		out := vector.NewTypeValueEmpty(0, bitvec.Zero)
@@ -36,8 +36,8 @@ func castToType(sctx *super.Context, vec vector.Any, index []uint32) (vector.Any
 			}
 			out.Append(val.Bytes())
 		}
-		return out, errs, true
+		return out, errs, "", true
 	default:
-		return nil, nil, false
+		return nil, nil, "", false
 	}
 }
diff --git a/runtime/ztests/expr/cast/string.yaml b/runtime/ztests/expr/cast/string.yaml
@@ -21,6 +21,8 @@ input: |
   1.2.3.4/32
   0x68692c20776f726c64
   0x666f6f20626172
+  0x00
+  0xc328
   "hi, world"
   "foo bar"
   {foo:"bar"}
@@ -46,6 +48,8 @@ output: |
   "1.2.3.4/32"
   "hi, world"
   "foo bar"
+  "\u0000"
+  error({message:"cannot cast to string: invalid UTF-8",on:0xc328})
   "hi, world"
   "foo bar"
   "{foo:\"bar\"}"

Original file line number	Diff line number	Diff line change
`@@ -4,14 +4,14 @@ import (`
`4`	`4`	`"github.com/brimdata/super/vector"`
`5`	`5`	`)`
`6`	`6`
`7`		`-func castToBytes(vec vector.Any, index []uint32) (vector.Any, []uint32, bool) {`
	`7`	`+func castToBytes(vec vector.Any, index []uint32) (vector.Any, []uint32, string, bool) {`
`8`	`8`	`strVec, ok := vec.(*vector.String)`
`9`	`9`	`if !ok {`
`10`		`- return nil, nil, false`
	`10`	`+ return nil, nil, "", false`
`11`	`11`	`}`
`12`	`12`	`out := vector.Any(vector.NewBytes(strVec.Table(), vector.NullsOf(strVec)))`
`13`	`13`	`if index != nil {`
`14`	`14`	`out = vector.Pick(out, index)`
`15`	`15`	`}`
`16`		`- return out, nil, true`
	`16`	`+ return out, nil, "", true`
`17`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ func To(sctx *super.Context, vec vector.Any, typ super.Type) vector.Any {`
`13`	`13`	`var c caster`
`14`	`14`	`id := typ.ID()`
`15`	`15`	`if super.IsNumber(id) {`
`16`		`- c = func(vec vector.Any, index []uint32) (vector.Any, []uint32, bool) {`
	`16`	`+ c = func(vec vector.Any, index []uint32) (vector.Any, []uint32, string, bool) {`
`17`	`17`	`return castToNumber(vec, typ, index)`
`18`	`18`	`}`
`19`	`19`	`} else {`
`@@ -29,29 +29,30 @@ func To(sctx *super.Context, vec vector.Any, typ super.Type) vector.Any {`
`29`	`29`	`case super.IDNet:`
`30`	`30`	`c = castToNet`
`31`	`31`	`case super.IDType:`
`32`		`- c = func(vec vector.Any, index []uint32) (vector.Any, []uint32, bool) {`
	`32`	`+ c = func(vec vector.Any, index []uint32) (vector.Any, []uint32, string, bool) {`
`33`	`33`	`return castToType(sctx, vec, index)`
`34`	`34`	`}`
`35`	`35`	`default:`
`36`		`- return errCastFailed(sctx, vec, typ)`
	`36`	`+ return errCastFailed(sctx, vec, typ, "")`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`	`return assemble(sctx, vec, typ, c)`
`40`	`40`	`}`
`41`	`41`
`42`		`-type caster func(vector.Any, []uint32) (vector.Any, []uint32, bool)`
	`42`	`+type caster func(vector.Any, []uint32) (vector.Any, []uint32, string, bool)`
`43`	`43`
`44`	`44`	`func assemble(sctx *super.Context, vec vector.Any, typ super.Type, fn caster) vector.Any {`
`45`	`45`	`var out vector.Any`
`46`	`46`	`var errs []uint32`
	`47`	`+ var errMsg string`
`47`	`48`	`var ok bool`
`48`	`49`	`switch vec := vec.(type) {`
`49`	`50`	`case *vector.Const:`
`50`	`51`	`return castConst(sctx, vec, typ)`
`51`	`52`	`case *vector.View:`
`52`		`- out, errs, ok = fn(vec.Any, vec.Index)`
	`53`	`+ out, errs, errMsg, ok = fn(vec.Any, vec.Index)`
`53`	`54`	`case *vector.Dict:`
`54`		`- out, errs, ok = fn(vec.Any, nil)`
	`55`	`+ out, errs, errMsg, ok = fn(vec.Any, nil)`
`55`	`56`	`if ok {`
`56`	`57`	`if len(errs) > 0 {`
`57`	`58`	`index, counts, nulls, nerrs := vec.RebuildDropTags(errs...)`
`@@ -62,13 +63,13 @@ func assemble(sctx *super.Context, vec vector.Any, typ super.Type, fn caster) ve`
`62`	`63`	`}`
`63`	`64`	`}`
`64`	`65`	`default:`
`65`		`- out, errs, ok = fn(vec, nil)`
	`66`	`+ out, errs, errMsg, ok = fn(vec, nil)`
`66`	`67`	`}`
`67`	`68`	`if !ok {`
`68`		`- return errCastFailed(sctx, vec, typ)`
	`69`	`+ return errCastFailed(sctx, vec, typ, errMsg)`
`69`	`70`	`}`
`70`	`71`	`if len(errs) > 0 {`
`71`		`- return vector.Combine(out, errs, errCastFailed(sctx, vector.Pick(vec, errs), typ))`
	`72`	`+ return vector.Combine(out, errs, errCastFailed(sctx, vector.Pick(vec, errs), typ, errMsg))`
`72`	`73`	`}`
`73`	`74`	`return out`
`74`	`75`	`}`
`@@ -88,17 +89,21 @@ func castConst(sctx super.Context, vec vector.Const, typ super.Type) vector.An`
`88`	`89`	`trueCount++`
`89`	`90`	`}`
`90`	`91`	`}`
`91`		`- err := errCastFailed(sctx, vector.NewConst(vec.Value(), vec.Len()-trueCount, bitvec.Zero), typ)`
	`92`	`+ err := errCastFailed(sctx, vector.NewConst(vec.Value(), vec.Len()-trueCount, bitvec.Zero), typ, "")`
`92`	`93`	`nulls := vector.NewConst(super.NewValue(typ, nil), trueCount, bitvec.Zero)`
`93`	`94`	`return vector.NewDynamic(index, []vector.Any{err, nulls})`
`94`	`95`	`}`
`95`		`- return errCastFailed(sctx, vec, typ)`
	`96`	`+ return errCastFailed(sctx, vec, typ, "")`
`96`	`97`	`}`
`97`	`98`	`return vector.NewConst(val, vec.Len(), vec.Nulls)`
`98`	`99`	`}`
`99`	`100`
`100`		`-func errCastFailed(sctx *super.Context, vec vector.Any, typ super.Type) vector.Any {`
`101`		`- return vector.NewWrappedError(sctx, "cannot cast to "+sup.FormatType(typ), vec)`
	`101`	`+func errCastFailed(sctx *super.Context, vec vector.Any, typ super.Type, msgSuffix string) vector.Any {`
	`102`	`+ msg := "cannot cast to " + sup.FormatType(typ)`
	`103`	`+ if msgSuffix != "" {`
	`104`	`+ msg = msg + ": " + msgSuffix`
	`105`	`+ }`
	`106`	`+ return vector.NewWrappedError(sctx, msg, vec)`
`102`	`107`	`}`
`103`	`108`
`104`	`109`	`func lengthOf(vec vector.Any, index []uint32) uint32 {`
Original file line number	Diff line number	Diff line change
`@@ -8,10 +8,10 @@ import (`
`8`	`8`	`"github.com/brimdata/super/vector/bitvec"`
`9`	`9`	`)`
`10`	`10`
`11`		`-func castToIP(vec vector.Any, index []uint32) (vector.Any, []uint32, bool) {`
	`11`	`+func castToIP(vec vector.Any, index []uint32) (vector.Any, []uint32, string, bool) {`
`12`	`12`	`switch vec := vec.(type) {`
`13`	`13`	`case *vector.IP:`
`14`		`- return vec, nil, true`
	`14`	`+ return vec, nil, "", true`
`15`	`15`	`case *vector.String:`
`16`	`16`	`n := lengthOf(vec, index)`
`17`	`17`	`var nulls bitvec.Bits`
`@@ -37,16 +37,16 @@ func castToIP(vec vector.Any, index []uint32) (vector.Any, []uint32, bool) {`
`37`	`37`	`}`
`38`	`38`	`ips = append(ips, ip)`
`39`	`39`	`}`
`40`		`- return vector.NewIP(ips, nulls), errs, true`
	`40`	`+ return vector.NewIP(ips, nulls), errs, "", true`
`41`	`41`	`default:`
`42`		`- return nil, nil, false`
	`42`	`+ return nil, nil, "", false`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`
`46`		`-func castToNet(vec vector.Any, index []uint32) (vector.Any, []uint32, bool) {`
	`46`	`+func castToNet(vec vector.Any, index []uint32) (vector.Any, []uint32, string, bool) {`
`47`	`47`	`switch vec := vec.(type) {`
`48`	`48`	`case *vector.Net:`
`49`		`- return vec, nil, true`
	`49`	`+ return vec, nil, "", true`
`50`	`50`	`case *vector.String:`
`51`	`51`	`n := lengthOf(vec, index)`
`52`	`52`	`var nulls bitvec.Bits`
`@@ -72,8 +72,8 @@ func castToNet(vec vector.Any, index []uint32) (vector.Any, []uint32, bool) {`
`72`	`72`	`}`
`73`	`73`	`nets = append(nets, net)`
`74`	`74`	`}`
`75`		`- return vector.NewNet(nets, nulls), errs, true`
	`75`	`+ return vector.NewNet(nets, nulls), errs, "", true`
`76`	`76`	`default:`
`77`		`- return nil, nil, false`
	`77`	`+ return nil, nil, "", false`
`78`	`78`	`}`
`79`	`79`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,10 +17,10 @@ type numeric interface {`
`17`	`17`	`constraints.Float \| constraints.Integer`
`18`	`18`	`}`
`19`	`19`
`20`		`-func castToNumber(vec vector.Any, typ super.Type, index []uint32) (vector.Any, []uint32, bool) {`
	`20`	`+func castToNumber(vec vector.Any, typ super.Type, index []uint32) (vector.Any, []uint32, string, bool) {`
`21`	`21`	`if vec.Type().ID() == super.IDString {`
`22`	`22`	`out, errs := castStringToNumber(vec, typ, index)`
`23`		`- return out, errs, true`
	`23`	`+ return out, errs, "", true`
`24`	`24`	`}`
`25`	`25`	`nulls := vector.NullsOf(vec)`
`26`	`26`	`if index != nil {`
`@@ -32,21 +32,21 @@ func castToNumber(vec vector.Any, typ super.Type, index []uint32) (vector.Any, [`
`32`	`32`	`if len(errs) > 0 {`
`33`	`33`	`nulls = nulls.Pick(inverseIndex(errs, nulls.Len()))`
`34`	`34`	`}`
`35`		`- return vector.NewInt(typ, vals, nulls), errs, true`
	`35`	`+ return vector.NewInt(typ, vals, nulls), errs, "", true`
`36`	`36`	`case super.IsUnsigned(id):`
`37`	`37`	`vals, errs := toNumeric[uint64](vec, typ, index)`
`38`	`38`	`if len(errs) > 0 {`
`39`	`39`	`nulls = nulls.Pick(inverseIndex(errs, nulls.Len()))`
`40`	`40`	`}`
`41`		`- return vector.NewUint(typ, vals, nulls), errs, true`
	`41`	`+ return vector.NewUint(typ, vals, nulls), errs, "", true`
`42`	`42`	`case super.IsFloat(id):`
`43`	`43`	`vals, errs := toNumeric[float64](vec, typ, index)`
`44`	`44`	`if errs != nil {`
`45`	`45`	`nulls = nulls.Pick(inverseIndex(errs, nulls.Len()))`
`46`	`46`	`}`
`47`		`- return vector.NewFloat(typ, vals, nulls), errs, true`
	`47`	`+ return vector.NewFloat(typ, vals, nulls), errs, "", true`
`48`	`48`	`default:`
`49`		`- return nil, nil, false`
	`49`	`+ return nil, nil, "", false`
`50`	`50`	`}`
`51`	`51`	`}`
`52`	`52`
Original file line number	Diff line number	Diff line change
`@@ -7,10 +7,10 @@ import (`
`7`	`7`	`"github.com/brimdata/super/vector/bitvec"`
`8`	`8`	`)`
`9`	`9`
`10`		`-func castToType(sctx *super.Context, vec vector.Any, index []uint32) (vector.Any, []uint32, bool) {`
	`10`	`+func castToType(sctx *super.Context, vec vector.Any, index []uint32) (vector.Any, []uint32, string, bool) {`
`11`	`11`	`switch vec := vec.(type) {`
`12`	`12`	`case *vector.TypeValue:`
`13`		`- return vec, nil, true`
	`13`	`+ return vec, nil, "", true`
`14`	`14`	`case *vector.String:`
`15`	`15`	`n := lengthOf(vec, index)`
`16`	`16`	`out := vector.NewTypeValueEmpty(0, bitvec.Zero)`
`@@ -36,8 +36,8 @@ func castToType(sctx *super.Context, vec vector.Any, index []uint32) (vector.Any`
`36`	`36`	`}`
`37`	`37`	`out.Append(val.Bytes())`
`38`	`38`	`}`
`39`		`- return out, errs, true`
	`39`	`+ return out, errs, "", true`
`40`	`40`	`default:`
`41`		`- return nil, nil, false`
	`41`	`+ return nil, nil, "", false`
`42`	`42`	`}`
`43`	`43`	`}`