Implement vector rename operator

compiler/kernel/op.go

@@ -226,18 +226,9 @@ func (b *Builder) compileLeaf(o dag.Op, parent zbuf.Puller) (zbuf.Puller, error)
 		return op.NewApplier(b.rctx, parent, putter, b.resetters), nil
 	case *dag.Rename:
 		b.resetResetters()
-		var srcs, dsts []*expr.Lval
-		for _, a := range v.Args {
-			src, err := b.compileLval(a.RHS)
-			if err != nil {
-				return nil, err
-			}
-			dst, err := b.compileLval(a.LHS)
-			if err != nil {
-				return nil, err
-			}
-			srcs = append(srcs, src)
-			dsts = append(dsts, dst)
+		srcs, dsts, err := b.compileAssignmentsToLvals(v.Args)
+		if err != nil {
+			return nil, err
 		}
 		renamer := expr.NewRenamer(b.rctx.Zctx, srcs, dsts)
 		return op.NewApplier(b.rctx, parent, renamer, b.resetters), nil
@@ -447,6 +438,23 @@ func (b *Builder) compileAssignments(assignments []dag.Assignment) ([]expr.Assig
 	return keys, nil
 }
 
+func (b *Builder) compileAssignmentsToLvals(assignments []dag.Assignment) ([]*expr.Lval, []*expr.Lval, error) {
+	var srcs, dsts []*expr.Lval
+	for _, a := range assignments {
+		src, err := b.compileLval(a.RHS)
+		if err != nil {
+			return nil, nil, err
+		}
+		dst, err := b.compileLval(a.LHS)
+		if err != nil {
+			return nil, nil, err
+		}
+		srcs = append(srcs, src)
+		dsts = append(dsts, dst)
+	}
+	return srcs, dsts, nil
+}
+
 func splitAssignments(assignments []expr.Assignment) ([]*expr.Lval, []expr.Evaluator) {
 	n := len(assignments)
 	lhs := make([]*expr.Lval, 0, n)

compiler/kernel/vop.go

@@ -100,6 +100,13 @@ func (b *Builder) compileVamLeaf(o dag.Op, parent vector.Puller) (vector.Puller,
 			return nil, err
 		}
 		return vamop.NewYield(b.zctx(), parent, []expr.Evaluator{expr.NewPutter(b.zctx(), e)}), nil
+	case *dag.Rename:
+		srcs, dsts, err := b.compileAssignmentsToLvals(o.Args)
+		if err != nil {
+			return nil, err
+		}
+		renamer := expr.NewRenamer(b.zctx(), srcs, dsts)
+		return vamop.NewYield(b.zctx(), parent, []expr.Evaluator{renamer}), nil
 	case *dag.Yield:
 		exprs, err := b.compileVamExprs(o.Exprs)
 		if err != nil {

runtime/sam/expr/renamer.go

@@ -29,12 +29,20 @@ func NewRenamer(zctx *zed.Context, srcs, dsts []*Lval) *Renamer {
 }
 
 func (r *Renamer) Eval(ectx Context, this zed.Value) zed.Value {
+	val, err := r.EvalToValAndError(ectx, this)
+	if err != nil {
+		return r.zctx.WrapError(err.Error(), this)
+	}
+	return val
+}
+
+func (r *Renamer) EvalToValAndError(ectx Context, this zed.Value) (zed.Value, error) {
 	if !zed.IsRecordType(this.Type()) {
-		return this
+		return this, nil
 	}
 	srcs, dsts, err := r.evalFields(ectx, this)
 	if err != nil {
-		return r.zctx.WrapError(fmt.Sprintf("rename: %s", err), this)
+		return zed.Null, fmt.Errorf("rename: %w", err)
 	}
 	id := this.Type().ID()
 	m, ok := r.typeMap[id]
@@ -48,11 +56,11 @@ func (r *Renamer) Eval(ectx Context, this zed.Value) zed.Value {
 		var err error
 		typ, err = r.computeType(zed.TypeRecordOf(this.Type()), srcs, dsts)
 		if err != nil {
-			return r.zctx.WrapError(fmt.Sprintf("rename: %s", err), this)
+			return zed.Null, fmt.Errorf("rename: %w", err)
 		}
 		m[string(r.fieldsStr)] = typ
 	}
-	return zed.NewValue(typ, this.Bytes())
+	return zed.NewValue(typ, this.Bytes()), nil
 }
 
 func CheckRenameField(src, dst field.Path) error {

runtime/vam/expr/renamer.go

@@ -0,0 +1,35 @@
+package expr
+
+import (
+	"github.com/brimdata/zed"
+	"github.com/brimdata/zed/runtime/sam/expr"
+	"github.com/brimdata/zed/vector"
+)
+
+// Renamer renames one or more fields in a record.  See [expr.Renamer], on which
+// it relies, for more detail.
+type Renamer struct {
+	zctx    *zed.Context
+	renamer *expr.Renamer
+}
+
+func NewRenamer(zctx *zed.Context, srcs, dsts []*expr.Lval) *Renamer {
+	return &Renamer{zctx, expr.NewRenamer(zctx, srcs, dsts)}
+}
+
+func (r *Renamer) Eval(vec vector.Any) vector.Any {
+	return vector.Apply(false, r.eval, vec)
+}
+
+func (r *Renamer) eval(vecs ...vector.Any) vector.Any {
+	vec := vecs[0]
+	recVec, ok := vector.Under(vec).(*vector.Record)
+	if !ok {
+		return vec
+	}
+	val, err := r.renamer.EvalToValAndError(nil, zed.NewValue(vec.Type(), nil))
+	if err != nil {
+		return vector.NewWrappedError(r.zctx, err.Error(), vec)
+	}
+	return vector.NewRecord(val.Type().(*zed.TypeRecord), recVec.Fields, recVec.Len(), recVec.Nulls)
+}

runtime/sam/expr/ztests/rename-error-dupe.yaml → runtime/ztests/op/rename-error-dupe.yaml

@@ -1,7 +1,11 @@
 zed: rename foo:=goo
 
+vector: true
+
 input: |
   {foo:"foo1",goo:"goo1"}
+  {foo:"foo2",goo:"goo2"}
 
 output: |
   error({message:"rename: duplicate field: \"foo\"",on:{foo:"foo1",goo:"goo1"}})
+  error({message:"rename: duplicate field: \"foo\"",on:{foo:"foo2",goo:"goo2"}})

runtime/sam/expr/ztests/rename-error-move.yaml → runtime/ztests/op/rename-error-move.yaml

@@ -1,5 +1,7 @@
 zed: rename dst:=id.resp_h
 
+vector: true
+
 input: |
   {id:{orig_h:10.164.94.120,orig_p:39681(port=uint16),resp_h:10.47.3.155,resp_p:3389(port)}}
 

runtime/sam/expr/ztests/rename-foo-bar.yaml → runtime/ztests/op/rename-foo-bar.yaml

@@ -1,5 +1,7 @@
 zed: rename f:=foo, b:=bar
 
+vector: true
+
 input: |
   {foo:"foo0"}
   {foo:"foo1",goo:"goo1"}

runtime/sam/expr/ztests/rename-nested.yaml → runtime/ztests/op/rename-nested.yaml

@@ -1,5 +1,7 @@
 zed: rename id.dst:=id.resp_h, id.src:=id.orig_h, net:=id
 
+vector: true
+
 input: |
   {id:{orig_h:10.164.94.120,orig_p:39681(port=uint16),resp_h:10.47.3.155,resp_p:3389(port)}}
   {id:{orig_h:10.164.94.121,orig_p:39681(port=uint16),resp_h:10.47.3.155,resp_p:3390(port)}}

runtime/sam/op/ztests/rename-non-record.yaml → runtime/ztests/op/rename-non-record.yaml

@@ -1,5 +1,7 @@
 zed: rename a := b
 
+vector: true
+
 input: |
   1