diff --git a/executor.go b/executor.go
index 97f42acf1..589b0ace5 100644
--- a/executor.go
+++ b/executor.go
@@ -138,8 +138,8 @@ func (e *Executor) executeCall(ctx context.Context, index string, c *pql.Call, s
 		return e.executeCount(ctx, index, c, slices, opt)
 	case "SetBit":
 		return e.executeSetBit(ctx, index, c, opt)
-	case "SetFieldValue":
-		return nil, e.executeSetFieldValue(ctx, index, c, opt)
+	case "SetValue":
+		return nil, e.executeSetValue(ctx, index, c, opt)
 	case "SetRowAttrs":
 		return nil, e.executeSetRowAttrs(ctx, index, c, opt)
 	case "SetColumnAttrs":
@@ -1107,46 +1107,40 @@ func (e *Executor) executeSetBitView(ctx context.Context, index string, c *pql.C
 	return ret, nil
 }
 
-// executeSetFieldValue executes a SetFieldValue() call.
-func (e *Executor) executeSetFieldValue(ctx context.Context, index string, c *pql.Call, opt *ExecOptions) error {
-	frameName, ok := c.Args["frame"].(string)
-	if !ok {
-		return errors.New("SetFieldValue() frame required")
-	}
-
-	// Retrieve frame.
-	frame := e.Holder.Frame(index, frameName)
-	if frame == nil {
-		return ErrFrameNotFound
-	}
-
+// executeSetValue executes a SetValue() call.
+func (e *Executor) executeSetValue(ctx context.Context, index string, c *pql.Call, opt *ExecOptions) error {
 	// Parse labels.
 	columnID, ok, err := c.UintArg(columnLabel)
 	if err != nil {
-		return fmt.Errorf("reading SetFieldValue() column: %v", err)
+		return fmt.Errorf("reading SetValue() column: %v", err)
 	} else if !ok {
-		return fmt.Errorf("SetFieldValue() column field '%v' required", columnLabel)
+		return fmt.Errorf("SetValue() column field '%v' required", columnLabel)
 	}
 
 	// Copy args and remove reserved fields.
 	args := pql.CopyArgs(c.Args)
-	delete(args, "frame")
 	// While frame could technically work as a ColumnAttr argument, we are treating it as a reserved word primarily to avoid confusion.
 	// Also, if we ever need to make ColumnAttrs frame-specific, then having this reserved word prevents backward incompatibility.
 	delete(args, columnLabel)
 
 	// Set values.
 	for name, value := range args {
+		// Retrieve frame.
+		frame := e.Holder.Frame(index, name)
+		if frame == nil {
+			return ErrFrameNotFound
+		}
+
 		switch value := value.(type) {
 		case int64:
-			if _, err := frame.SetFieldValue(columnID, name, value); err != nil {
+			if _, err := frame.SetValue(columnID, value); err != nil {
 				return err
 			}
 		default:
 			return ErrInvalidFieldValueType
 		}
+		frame.Stats.Count("SetValue", 1, 1.0)
 	}
-	frame.Stats.Count("SetFieldValue", 1, 1.0)
 
 	// Do not forward call if this is already being forwarded.
 	if opt.Remote {
diff --git a/executor_test.go b/executor_test.go
index fbce4d52d..a8cce5194 100644
--- a/executor_test.go
+++ b/executor_test.go
@@ -263,8 +263,8 @@ func TestExecutor_Execute_SetBit(t *testing.T) {
 	}
 }
 
-// Ensure a SetFieldValue() query can be executed.
-func TestExecutor_Execute_SetFieldValue(t *testing.T) {
+// Ensure a SetValue() query can be executed.
+func TestExecutor_Execute_SetValue(t *testing.T) {
 	t.Run("OK", func(t *testing.T) {
 		hldr := test.MustOpenHolder()
 		defer hldr.Close()
@@ -283,9 +283,9 @@ func TestExecutor_Execute_SetFieldValue(t *testing.T) {
 
 		// Set field values.
 		e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
-		if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetFieldValue(col=10, frame=f, f=25)`), nil, nil); err != nil {
+		if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetValue(col=10, f=25)`), nil, nil); err != nil {
 			t.Fatal(err)
-		} else if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetFieldValue(col=100, frame=f, f=10)`), nil, nil); err != nil {
+		} else if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetValue(col=100, f=10)`), nil, nil); err != nil {
 			t.Fatal(err)
 		}
 
@@ -319,30 +319,23 @@ func TestExecutor_Execute_SetFieldValue(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		t.Run("ErrFrameRequired", func(t *testing.T) {
-			e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
-			if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetFieldValue(col=10, f=100)`), nil, nil); err == nil || err.Error() != `SetFieldValue() frame required` {
-				t.Fatalf("unexpected error: %s", err)
-			}
-		})
-
 		t.Run("ErrColumnFieldRequired", func(t *testing.T) {
 			e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
-			if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetFieldValue(invalid_column_name=10, frame=f, f=100)`), nil, nil); err == nil || err.Error() != `SetFieldValue() column field 'col' required` {
+			if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetValue(invalid_column_name=10, f=100)`), nil, nil); err == nil || err.Error() != `SetValue() column field 'col' required` {
 				t.Fatalf("unexpected error: %s", err)
 			}
 		})
 
 		t.Run("ErrColumnFieldValue", func(t *testing.T) {
 			e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
-			if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetFieldValue(invalid_column_name="bad_column", frame=f, f=100)`), nil, nil); err == nil || err.Error() != `SetFieldValue() column field 'col' required` {
+			if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetValue(invalid_column_name="bad_column", f=100)`), nil, nil); err == nil || err.Error() != `SetValue() column field 'col' required` {
 				t.Fatalf("unexpected error: %s", err)
 			}
 		})
 
 		t.Run("ErrInvalidFieldValueType", func(t *testing.T) {
 			e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
-			if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetFieldValue(col=10, frame=f, f="hello")`), nil, nil); err == nil || err.Error() != `invalid field value type` {
+			if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetValue(col=10, f="hello")`), nil, nil); err == nil || err.Error() != `invalid field value type` {
 				t.Fatalf("unexpected error: %s", err)
 			}
 		})
@@ -598,14 +591,14 @@ func TestExecutor_Execute_MinMax(t *testing.T) {
 		SetBit(frame=x, row=1, col=1)
 		SetBit(frame=x, row=2, col=`+strconv.Itoa(SliceWidth+2)+`)
 
-		SetFieldValue(frame=f, f=20, col=0)
-		SetFieldValue(frame=f, f=-5, col=1)
-		SetFieldValue(frame=f, f=-5, col=2)
-		SetFieldValue(frame=f, f=10, col=3)
-		SetFieldValue(frame=f, f=30, col=`+strconv.Itoa(SliceWidth)+`)
-		SetFieldValue(frame=f, f=40, col=`+strconv.Itoa(SliceWidth+2)+`)
-		SetFieldValue(frame=f, f=50, col=`+strconv.Itoa((5*SliceWidth)+100)+`)
-		SetFieldValue(frame=f, f=60, col=`+strconv.Itoa(SliceWidth+1)+`)
+		SetValue(f=20, col=0)
+		SetValue(f=-5, col=1)
+		SetValue(f=-5, col=2)
+		SetValue(f=10, col=3)
+		SetValue(f=30, col=`+strconv.Itoa(SliceWidth)+`)
+		SetValue(f=40, col=`+strconv.Itoa(SliceWidth+2)+`)
+		SetValue(f=50, col=`+strconv.Itoa((5*SliceWidth)+100)+`)
+		SetValue(f=60, col=`+strconv.Itoa(SliceWidth+1)+`)
 	`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
@@ -706,13 +699,13 @@ func TestExecutor_Execute_Sum(t *testing.T) {
 		SetBit(frame=x, row=0, col=0)
 		SetBit(frame=x, row=0, col=`+strconv.Itoa(SliceWidth+1)+`)
 
-		SetFieldValue(frame=foo, foo=20, col=0)
-		SetFieldValue(frame=bar, bar=2000, col=0)
-		SetFieldValue(frame=foo, foo=30, col=`+strconv.Itoa(SliceWidth)+`)
-		SetFieldValue(frame=foo, foo=40, col=`+strconv.Itoa(SliceWidth+2)+`)
-		SetFieldValue(frame=foo, foo=50, col=`+strconv.Itoa((5*SliceWidth)+100)+`)
-		SetFieldValue(frame=foo, foo=60, col=`+strconv.Itoa(SliceWidth+1)+`)
-		SetFieldValue(frame=other, other=1000, col=0)
+		SetValue(foo=20, col=0)
+		SetValue(bar=2000, col=0)
+		SetValue(foo=30, col=`+strconv.Itoa(SliceWidth)+`)
+		SetValue(foo=40, col=`+strconv.Itoa(SliceWidth+2)+`)
+		SetValue(foo=50, col=`+strconv.Itoa((5*SliceWidth)+100)+`)
+		SetValue(foo=60, col=`+strconv.Itoa(SliceWidth+1)+`)
+		SetValue(other=1000, col=0)
 	`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
@@ -827,15 +820,15 @@ func TestExecutor_Execute_FieldRange(t *testing.T) {
 		SetBit(frame=f, row=0, col=0)
 		SetBit(frame=f, row=0, col=`+strconv.Itoa(SliceWidth+1)+`)
 
-		SetFieldValue(frame=foo, foo=20, col=50)
-		SetFieldValue(frame=bar, bar=2000, col=50)
-		SetFieldValue(frame=foo, foo=30, col=`+strconv.Itoa(SliceWidth)+`)
-		SetFieldValue(frame=foo, foo=10, col=`+strconv.Itoa(SliceWidth+2)+`)
-		SetFieldValue(frame=foo, foo=20, col=`+strconv.Itoa((5*SliceWidth)+100)+`)
-		SetFieldValue(frame=foo, foo=60, col=`+strconv.Itoa(SliceWidth+1)+`)
-		SetFieldValue(frame=other, other=1000, col=0)
-		SetFieldValue(frame=edge, edge=100, col=0)
-		SetFieldValue(frame=edge, edge=-100, col=1)
+		SetValue(foo=20, col=50)
+		SetValue(bar=2000, col=50)
+		SetValue(foo=30, col=`+strconv.Itoa(SliceWidth)+`)
+		SetValue(foo=10, col=`+strconv.Itoa(SliceWidth+2)+`)
+		SetValue(foo=20, col=`+strconv.Itoa((5*SliceWidth)+100)+`)
+		SetValue(foo=60, col=`+strconv.Itoa(SliceWidth+1)+`)
+		SetValue(other=1000, col=0)
+		SetValue(edge=100, col=0)
+		SetValue(edge=-100, col=1)
 	`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
diff --git a/fragment.go b/fragment.go
index 8044f579b..f2d7ad986 100644
--- a/fragment.go
+++ b/fragment.go
@@ -510,8 +510,8 @@ func (f *Fragment) FieldValue(columnID uint64, bitDepth uint) (value uint64, exi
 	return value, true, nil
 }
 
-// SetFieldValue uses a column of bits to set a multi-bit value.
-func (f *Fragment) SetFieldValue(columnID uint64, bitDepth uint, value uint64) (changed bool, err error) {
+// SetValue uses a column of bits to set a multi-bit value.
+func (f *Fragment) SetValue(columnID uint64, bitDepth uint, value uint64) (changed bool, err error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 
@@ -541,8 +541,8 @@ func (f *Fragment) SetFieldValue(columnID uint64, bitDepth uint, value uint64) (
 	return changed, nil
 }
 
-// importSetFieldValue is a more efficient SetFieldValue just for imports.
-func (f *Fragment) importSetFieldValue(columnID uint64, bitDepth uint, value uint64) (changed bool, err error) {
+// importSetValue is a more efficient SetValue just for imports.
+func (f *Fragment) importSetValue(columnID uint64, bitDepth uint, value uint64) (changed bool, err error) {
 
 	for i := uint(0); i < bitDepth; i++ {
 		if value&(1<<i) != 0 {
@@ -1408,7 +1408,7 @@ func (f *Fragment) ImportValue(columnIDs, values []uint64, bitDepth uint) error
 		for i := range columnIDs {
 			columnID, value := columnIDs[i], values[i]
 
-			_, err := f.importSetFieldValue(columnID, bitDepth, value)
+			_, err := f.importSetValue(columnID, bitDepth, value)
 			if err != nil {
 				return errors.Wrap(err, "setting")
 			}
diff --git a/fragment_test.go b/fragment_test.go
index 5c5f03b16..f5205eb73 100644
--- a/fragment_test.go
+++ b/fragment_test.go
@@ -97,13 +97,13 @@ func TestFragment_ClearBit(t *testing.T) {
 }
 
 // Ensure a fragment can set & read a field value.
-func TestFragment_SetFieldValue(t *testing.T) {
+func TestFragment_SetValue(t *testing.T) {
 	t.Run("OK", func(t *testing.T) {
 		f := test.MustOpenFragment("i", "f", pilosa.ViewStandard, 0, "")
 		defer f.Close()
 
 		// Set value.
-		if changed, err := f.SetFieldValue(100, 16, 3829); err != nil {
+		if changed, err := f.SetValue(100, 16, 3829); err != nil {
 			t.Fatal(err)
 		} else if !changed {
 			t.Fatal("expected change")
@@ -119,7 +119,7 @@ func TestFragment_SetFieldValue(t *testing.T) {
 		}
 
 		// Setting value should return no change.
-		if changed, err := f.SetFieldValue(100, 16, 3829); err != nil {
+		if changed, err := f.SetValue(100, 16, 3829); err != nil {
 			t.Fatal(err)
 		} else if changed {
 			t.Fatal("expected no change")
@@ -131,14 +131,14 @@ func TestFragment_SetFieldValue(t *testing.T) {
 		defer f.Close()
 
 		// Set value.
-		if changed, err := f.SetFieldValue(100, 16, 3829); err != nil {
+		if changed, err := f.SetValue(100, 16, 3829); err != nil {
 			t.Fatal(err)
 		} else if !changed {
 			t.Fatal("expected change")
 		}
 
 		// Overwriting value should overwrite all bits.
-		if changed, err := f.SetFieldValue(100, 16, 2028); err != nil {
+		if changed, err := f.SetValue(100, 16, 2028); err != nil {
 			t.Fatal(err)
 		} else if !changed {
 			t.Fatal("expected change")
@@ -159,7 +159,7 @@ func TestFragment_SetFieldValue(t *testing.T) {
 		defer f.Close()
 
 		// Set value.
-		if changed, err := f.SetFieldValue(100, 10, 20); err != nil {
+		if changed, err := f.SetValue(100, 10, 20); err != nil {
 			t.Fatal(err)
 		} else if !changed {
 			t.Fatal("expected change")
@@ -195,7 +195,7 @@ func TestFragment_SetFieldValue(t *testing.T) {
 
 				m[columnID] = int64(value)
 
-				if _, err := f.SetFieldValue(columnID, bitDepth, value); err != nil {
+				if _, err := f.SetValue(columnID, bitDepth, value); err != nil {
 					t.Fatal(err)
 				}
 			}
@@ -227,13 +227,13 @@ func TestFragment_FieldSum(t *testing.T) {
 	defer f.Close()
 
 	// Set values.
-	if _, err := f.SetFieldValue(1000, bitDepth, 382); err != nil {
+	if _, err := f.SetValue(1000, bitDepth, 382); err != nil {
 		t.Fatal(err)
-	} else if _, err := f.SetFieldValue(2000, bitDepth, 300); err != nil {
+	} else if _, err := f.SetValue(2000, bitDepth, 300); err != nil {
 		t.Fatal(err)
-	} else if _, err := f.SetFieldValue(3000, bitDepth, 2818); err != nil {
+	} else if _, err := f.SetValue(3000, bitDepth, 2818); err != nil {
 		t.Fatal(err)
-	} else if _, err := f.SetFieldValue(4000, bitDepth, 300); err != nil {
+	} else if _, err := f.SetValue(4000, bitDepth, 300); err != nil {
 		t.Fatal(err)
 	}
 
@@ -266,19 +266,19 @@ func TestFragment_FieldMinMax(t *testing.T) {
 	defer f.Close()
 
 	// Set values.
-	if _, err := f.SetFieldValue(1000, bitDepth, 382); err != nil {
+	if _, err := f.SetValue(1000, bitDepth, 382); err != nil {
 		t.Fatal(err)
-	} else if _, err := f.SetFieldValue(2000, bitDepth, 300); err != nil {
+	} else if _, err := f.SetValue(2000, bitDepth, 300); err != nil {
 		t.Fatal(err)
-	} else if _, err := f.SetFieldValue(3000, bitDepth, 2818); err != nil {
+	} else if _, err := f.SetValue(3000, bitDepth, 2818); err != nil {
 		t.Fatal(err)
-	} else if _, err := f.SetFieldValue(4000, bitDepth, 300); err != nil {
+	} else if _, err := f.SetValue(4000, bitDepth, 300); err != nil {
 		t.Fatal(err)
-	} else if _, err := f.SetFieldValue(5000, bitDepth, 2818); err != nil {
+	} else if _, err := f.SetValue(5000, bitDepth, 2818); err != nil {
 		t.Fatal(err)
-	} else if _, err := f.SetFieldValue(6000, bitDepth, 2817); err != nil {
+	} else if _, err := f.SetValue(6000, bitDepth, 2817); err != nil {
 		t.Fatal(err)
-	} else if _, err := f.SetFieldValue(7000, bitDepth, 0); err != nil {
+	} else if _, err := f.SetValue(7000, bitDepth, 0); err != nil {
 		t.Fatal(err)
 	}
 
@@ -340,13 +340,13 @@ func TestFragment_FieldRange(t *testing.T) {
 		defer f.Close()
 
 		// Set values.
-		if _, err := f.SetFieldValue(1000, bitDepth, 382); err != nil {
+		if _, err := f.SetValue(1000, bitDepth, 382); err != nil {
 			t.Fatal(err)
-		} else if _, err := f.SetFieldValue(2000, bitDepth, 300); err != nil {
+		} else if _, err := f.SetValue(2000, bitDepth, 300); err != nil {
 			t.Fatal(err)
-		} else if _, err := f.SetFieldValue(3000, bitDepth, 2818); err != nil {
+		} else if _, err := f.SetValue(3000, bitDepth, 2818); err != nil {
 			t.Fatal(err)
-		} else if _, err := f.SetFieldValue(4000, bitDepth, 300); err != nil {
+		} else if _, err := f.SetValue(4000, bitDepth, 300); err != nil {
 			t.Fatal(err)
 		}
 
@@ -363,13 +363,13 @@ func TestFragment_FieldRange(t *testing.T) {
 		defer f.Close()
 
 		// Set values.
-		if _, err := f.SetFieldValue(1000, bitDepth, 382); err != nil {
+		if _, err := f.SetValue(1000, bitDepth, 382); err != nil {
 			t.Fatal(err)
-		} else if _, err := f.SetFieldValue(2000, bitDepth, 300); err != nil {
+		} else if _, err := f.SetValue(2000, bitDepth, 300); err != nil {
 			t.Fatal(err)
-		} else if _, err := f.SetFieldValue(3000, bitDepth, 2818); err != nil {
+		} else if _, err := f.SetValue(3000, bitDepth, 2818); err != nil {
 			t.Fatal(err)
-		} else if _, err := f.SetFieldValue(4000, bitDepth, 300); err != nil {
+		} else if _, err := f.SetValue(4000, bitDepth, 300); err != nil {
 			t.Fatal(err)
 		}
 
@@ -386,17 +386,17 @@ func TestFragment_FieldRange(t *testing.T) {
 		defer f.Close()
 
 		// Set values.
-		if _, err := f.SetFieldValue(1000, bitDepth, 382); err != nil {
+		if _, err := f.SetValue(1000, bitDepth, 382); err != nil {
 			t.Fatal(err)
-		} else if _, err := f.SetFieldValue(2000, bitDepth, 300); err != nil {
+		} else if _, err := f.SetValue(2000, bitDepth, 300); err != nil {
 			t.Fatal(err)
-		} else if _, err := f.SetFieldValue(3000, bitDepth, 2817); err != nil {
+		} else if _, err := f.SetValue(3000, bitDepth, 2817); err != nil {
 			t.Fatal(err)
-		} else if _, err := f.SetFieldValue(4000, bitDepth, 301); err != nil {
+		} else if _, err := f.SetValue(4000, bitDepth, 301); err != nil {
 			t.Fatal(err)
-		} else if _, err := f.SetFieldValue(5000, bitDepth, 1); err != nil {
+		} else if _, err := f.SetValue(5000, bitDepth, 1); err != nil {
 			t.Fatal(err)
-		} else if _, err := f.SetFieldValue(6000, bitDepth, 0); err != nil {
+		} else if _, err := f.SetValue(6000, bitDepth, 0); err != nil {
 			t.Fatal(err)
 		}
 
@@ -434,17 +434,17 @@ func TestFragment_FieldRange(t *testing.T) {
 		defer f.Close()
 
 		// Set values.
-		if _, err := f.SetFieldValue(1000, bitDepth, 382); err != nil {
+		if _, err := f.SetValue(1000, bitDepth, 382); err != nil {
 			t.Fatal(err)
-		} else if _, err := f.SetFieldValue(2000, bitDepth, 300); err != nil {
+		} else if _, err := f.SetValue(2000, bitDepth, 300); err != nil {
 			t.Fatal(err)
-		} else if _, err := f.SetFieldValue(3000, bitDepth, 2817); err != nil {
+		} else if _, err := f.SetValue(3000, bitDepth, 2817); err != nil {
 			t.Fatal(err)
-		} else if _, err := f.SetFieldValue(4000, bitDepth, 301); err != nil {
+		} else if _, err := f.SetValue(4000, bitDepth, 301); err != nil {
 			t.Fatal(err)
-		} else if _, err := f.SetFieldValue(5000, bitDepth, 1); err != nil {
+		} else if _, err := f.SetValue(5000, bitDepth, 1); err != nil {
 			t.Fatal(err)
-		} else if _, err := f.SetFieldValue(6000, bitDepth, 0); err != nil {
+		} else if _, err := f.SetValue(6000, bitDepth, 0); err != nil {
 			t.Fatal(err)
 		}
 
@@ -482,17 +482,17 @@ func TestFragment_FieldRange(t *testing.T) {
 		defer f.Close()
 
 		// Set values.
-		if _, err := f.SetFieldValue(1000, bitDepth, 382); err != nil {
+		if _, err := f.SetValue(1000, bitDepth, 382); err != nil {
 			t.Fatal(err)
-		} else if _, err := f.SetFieldValue(2000, bitDepth, 300); err != nil {
+		} else if _, err := f.SetValue(2000, bitDepth, 300); err != nil {
 			t.Fatal(err)
-		} else if _, err := f.SetFieldValue(3000, bitDepth, 2817); err != nil {
+		} else if _, err := f.SetValue(3000, bitDepth, 2817); err != nil {
 			t.Fatal(err)
-		} else if _, err := f.SetFieldValue(4000, bitDepth, 301); err != nil {
+		} else if _, err := f.SetValue(4000, bitDepth, 301); err != nil {
 			t.Fatal(err)
-		} else if _, err := f.SetFieldValue(5000, bitDepth, 1); err != nil {
+		} else if _, err := f.SetValue(5000, bitDepth, 1); err != nil {
 			t.Fatal(err)
-		} else if _, err := f.SetFieldValue(6000, bitDepth, 0); err != nil {
+		} else if _, err := f.SetValue(6000, bitDepth, 0); err != nil {
 			t.Fatal(err)
 		}
 
diff --git a/frame.go b/frame.go
index 1307df32d..ff20bddcc 100644
--- a/frame.go
+++ b/frame.go
@@ -726,10 +726,10 @@ func (f *Frame) FieldValue(columnID uint64, name string) (value int64, exists bo
 	return int64(v) + field.Min, true, nil
 }
 
-// SetFieldValue sets a field value for a column.
-func (f *Frame) SetFieldValue(columnID uint64, name string, value int64) (changed bool, err error) {
+// SetValue sets a field value for a column.
+func (f *Frame) SetValue(columnID uint64, value int64) (changed bool, err error) {
 	// Fetch field and validate value.
-	field := f.Field(name)
+	field := f.Field(f.name)
 	if field == nil {
 		return false, ErrFieldNotFound
 	} else if value < field.Min {
@@ -739,7 +739,7 @@ func (f *Frame) SetFieldValue(columnID uint64, name string, value int64) (change
 	}
 
 	// Fetch target view.
-	view, err := f.CreateViewIfNotExists(ViewFieldPrefix + name)
+	view, err := f.CreateViewIfNotExists(ViewFieldPrefix + f.name)
 	if err != nil {
 		return false, errors.Wrap(err, "creating view")
 	}
@@ -747,7 +747,7 @@ func (f *Frame) SetFieldValue(columnID uint64, name string, value int64) (change
 	// Determine base value to store.
 	baseValue := uint64(value - field.Min)
 
-	return view.SetFieldValue(columnID, field.BitDepth(), baseValue)
+	return view.setValue(columnID, field.BitDepth(), baseValue)
 }
 
 // FieldSum returns the sum and count for a field.
diff --git a/frame_test.go b/frame_test.go
index 8ad9b020a..9b7f9a336 100644
--- a/frame_test.go
+++ b/frame_test.go
@@ -72,7 +72,7 @@ func TestFrame_SetTimeQuantum(t *testing.T) {
 }
 
 // Ensure a frame can set & read a field value.
-func TestFrame_SetFieldValue(t *testing.T) {
+func TestFrame_SetValue(t *testing.T) {
 	t.Run("OK", func(t *testing.T) {
 		idx := test.MustOpenIndex()
 		defer idx.Close()
@@ -87,7 +87,7 @@ func TestFrame_SetFieldValue(t *testing.T) {
 		}
 
 		// Set value on field.
-		if changed, err := f.SetFieldValue(100, "f", 21); err != nil {
+		if changed, err := f.SetValue(100, 21); err != nil {
 			t.Fatal(err)
 		} else if !changed {
 			t.Fatal("expected change")
@@ -103,7 +103,7 @@ func TestFrame_SetFieldValue(t *testing.T) {
 		}
 
 		// Setting value should return no change.
-		if changed, err := f.SetFieldValue(100, "f", 21); err != nil {
+		if changed, err := f.SetValue(100, 21); err != nil {
 			t.Fatal(err)
 		} else if changed {
 			t.Fatal("expected no change")
@@ -124,14 +124,14 @@ func TestFrame_SetFieldValue(t *testing.T) {
 		}
 
 		// Set value.
-		if changed, err := f.SetFieldValue(100, "f", 21); err != nil {
+		if changed, err := f.SetValue(100, 21); err != nil {
 			t.Fatal(err)
 		} else if !changed {
 			t.Fatal("expected change")
 		}
 
 		// Set different value.
-		if changed, err := f.SetFieldValue(100, "f", 23); err != nil {
+		if changed, err := f.SetValue(100, 23); err != nil {
 			t.Fatal(err)
 		} else if !changed {
 			t.Fatal("expected change")
@@ -152,16 +152,14 @@ func TestFrame_SetFieldValue(t *testing.T) {
 		defer idx.Close()
 
 		f, err := idx.CreateFrame("f", pilosa.FrameOptions{
-			Type: pilosa.FrameTypeInt,
-			Min:  0,
-			Max:  30,
+			Type: pilosa.FrameTypeSet,
 		})
 		if err != nil {
 			t.Fatal(err)
 		}
 
 		// Set value.
-		if _, err := f.SetFieldValue(100, "no_such_field", 21); err != pilosa.ErrFieldNotFound {
+		if _, err := f.SetValue(100, 21); err != pilosa.ErrFieldNotFound {
 			t.Fatalf("unexpected error: %s", err)
 		}
 	})
@@ -180,7 +178,7 @@ func TestFrame_SetFieldValue(t *testing.T) {
 		}
 
 		// Set value.
-		if _, err := f.SetFieldValue(100, "f", 15); err != pilosa.ErrFieldValueTooLow {
+		if _, err := f.SetValue(100, 15); err != pilosa.ErrFieldValueTooLow {
 			t.Fatalf("unexpected error: %s", err)
 		}
 	})
@@ -199,7 +197,7 @@ func TestFrame_SetFieldValue(t *testing.T) {
 		}
 
 		// Set value.
-		if _, err := f.SetFieldValue(100, "f", 31); err != pilosa.ErrFieldValueTooHigh {
+		if _, err := f.SetValue(100, 31); err != pilosa.ErrFieldValueTooHigh {
 			t.Fatalf("unexpected error: %s", err)
 		}
 	})
diff --git a/test/cluster.go b/test/cluster.go
index 77cf496a8..bf6858e79 100644
--- a/test/cluster.go
+++ b/test/cluster.go
@@ -150,30 +150,6 @@ func (t *TestCluster) SetBit(index, frame, view string, rowID, colID uint64, x *
 	return nil
 }
 
-func (t *TestCluster) SetFieldValue(index, frame string, columnID uint64, name string, value int64) error {
-	// Determine which node should receive the SetFieldValue.
-	c0 := t.Clusters[0] // use the first node's cluster to determine slice location.
-	slice := columnID / pilosa.SliceWidth
-	nodes := c0.SliceNodes(index, slice)
-
-	for _, node := range nodes {
-		c := t.clusterByID(node.ID)
-		if c == nil {
-			continue
-		}
-		f := c.Holder.Frame(index, frame)
-		if f == nil {
-			return fmt.Errorf("index/frame does not exist: %s/%s", index, frame)
-		}
-		_, err := f.SetFieldValue(columnID, name, value)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
 func (t *TestCluster) clusterByID(id string) *pilosa.Cluster {
 	for _, c := range t.Clusters {
 		if c.Node.ID == id {
diff --git a/utils_test.go b/utils_test.go
index 1732522d4..eb4170a19 100644
--- a/utils_test.go
+++ b/utils_test.go
@@ -141,30 +141,6 @@ func (t *ClusterCluster) SetBit(index, frame, view string, rowID, colID uint64,
 	return nil
 }
 
-func (t *ClusterCluster) SetFieldValue(index, frame string, columnID uint64, name string, value int64) error {
-	// Determine which node should receive the SetFieldValue.
-	c0 := t.Clusters[0] // use the first node's cluster to determine slice location.
-	slice := columnID / SliceWidth
-	nodes := c0.SliceNodes(index, slice)
-
-	for _, node := range nodes {
-		c := t.clusterByID(node.ID)
-		if c == nil {
-			continue
-		}
-		f := c.Holder.Frame(index, frame)
-		if f == nil {
-			return fmt.Errorf("index/frame does not exist: %s/%s", index, frame)
-		}
-		_, err := f.SetFieldValue(columnID, name, value)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
 func (t *ClusterCluster) clusterByID(id string) *Cluster {
 	for _, c := range t.Clusters {
 		if c.Node.ID == id {
diff --git a/view.go b/view.go
index f90bf64e9..0d36faf2a 100644
--- a/view.go
+++ b/view.go
@@ -333,14 +333,14 @@ func (v *View) FieldValue(columnID uint64, bitDepth uint) (value uint64, exists
 	return frag.FieldValue(columnID, bitDepth)
 }
 
-// SetFieldValue uses a column of bits to set a multi-bit value.
-func (v *View) SetFieldValue(columnID uint64, bitDepth uint, value uint64) (changed bool, err error) {
+// setValue uses a column of bits to set a multi-bit value.
+func (v *View) setValue(columnID uint64, bitDepth uint, value uint64) (changed bool, err error) {
 	slice := columnID / SliceWidth
 	frag, err := v.CreateFragmentIfNotExists(slice)
 	if err != nil {
 		return changed, err
 	}
-	return frag.SetFieldValue(columnID, bitDepth, value)
+	return frag.SetValue(columnID, bitDepth, value)
 }
 
 // FieldSum returns the sum & count of a field.