diff --git a/executor.go b/executor.go
index 854a9d8b9..de0d65df0 100644
--- a/executor.go
+++ b/executor.go
@@ -80,7 +80,6 @@ func (e *Executor) Execute(ctx context.Context, index string, q *pql.Query, slic
 	// MaxSlice can differ between inverse and standard views, so we need
 	// to send queries to different slices based on orientation.
 	var inverseSlices []uint64
-	rowLabel := DefaultRowLabel
 	columnLabel := DefaultColumnLabel
 
 	// If slices aren't specified, then include all of them.
@@ -131,10 +130,9 @@ func (e *Executor) Execute(ctx context.Context, index string, q *pql.Query, slic
 			if f == nil {
 				return nil, ErrFrameNotFound
 			}
-			rowLabel = f.RowLabel()
 
 			// If this call is to an inverse frame send to a different list of slices.
-			if call.IsInverse(rowLabel, columnLabel) {
+			if call.IsInverse(DefaultRowLabel, columnLabel) {
 				slices = inverseSlices
 			}
 		}
@@ -280,8 +278,7 @@ func (e *Executor) executeBitmapCall(ctx context.Context, index string, c *pql.C
 				} else {
 					frame, _ := c.Args["frame"].(string)
 					if fr := idx.Frame(frame); fr != nil {
-						rowLabel := fr.RowLabel()
-						rowID, _, err := c.UintArg(rowLabel)
+						rowID, _, err := c.UintArg(DefaultRowLabel)
 						if err != nil {
 							return nil, err
 						}
@@ -536,18 +533,17 @@ func (e *Executor) executeBitmapSlice(ctx context.Context, index string, c *pql.
 	if f == nil {
 		return nil, ErrFrameNotFound
 	}
-	rowLabel := f.RowLabel()
 
 	// Return an error if both the row and column label are specified.
-	rowID, rowOK, rowErr := c.UintArg(rowLabel)
+	rowID, rowOK, rowErr := c.UintArg(DefaultRowLabel)
 	columnID, columnOK, columnErr := c.UintArg(columnLabel)
 	if rowErr != nil || columnErr != nil {
 		return nil, fmt.Errorf("Bitmap() error with arg for col: %v or row: %v", columnErr, rowErr)
 	}
 	if rowOK && columnOK {
-		return nil, fmt.Errorf("Bitmap() cannot specify both %s and %s values", rowLabel, columnLabel)
+		return nil, fmt.Errorf("Bitmap() cannot specify both %s and %s values", DefaultRowLabel, columnLabel)
 	} else if !rowOK && !columnOK {
-		return nil, fmt.Errorf("Bitmap() must specify either %s or %s values", rowLabel, columnLabel)
+		return nil, fmt.Errorf("Bitmap() must specify either %s or %s values", DefaultRowLabel, columnLabel)
 	}
 
 	// Determine row or column orientation.
@@ -613,14 +609,13 @@ func (e *Executor) executeRangeSlice(ctx context.Context, index string, c *pql.C
 	if f == nil {
 		return nil, ErrFrameNotFound
 	}
-	rowLabel := f.RowLabel()
 
 	// Read row & column id.
 	columnID, columnOK, err := c.UintArg(columnLabel)
 	if err != nil {
 		return nil, fmt.Errorf("executeRangeSlice - reading column: %v", err)
 	}
-	rowID, rowOK, err := c.UintArg(rowLabel)
+	rowID, rowOK, err := c.UintArg(DefaultRowLabel)
 	if err != nil {
 		return nil, fmt.Errorf("executeRangeSlice - reading row: %v", err)
 	}
@@ -629,9 +624,9 @@ func (e *Executor) executeRangeSlice(ctx context.Context, index string, c *pql.C
 	var id uint64
 	var viewName string
 	if columnOK && rowOK {
-		return nil, fmt.Errorf("Range() cannot contain both %q and %q", columnLabel, rowLabel)
+		return nil, fmt.Errorf("Range() cannot contain both %q and %q", columnLabel, DefaultRowLabel)
 	} else if !columnOK && !rowOK {
-		return nil, fmt.Errorf("Range() must specify either %q or %q", columnLabel, rowLabel)
+		return nil, fmt.Errorf("Range() must specify either %q or %q", columnLabel, DefaultRowLabel)
 	} else if columnOK {
 		viewName, id = ViewInverse, columnID
 	} else {
@@ -906,14 +901,13 @@ func (e *Executor) executeClearBit(ctx context.Context, index string, c *pql.Cal
 
 	// Retrieve labels.
 	columnLabel := idx.ColumnLabel()
-	rowLabel := f.RowLabel()
 
 	// Read fields using labels.
-	rowID, ok, err := c.UintArg(rowLabel)
+	rowID, ok, err := c.UintArg(DefaultRowLabel)
 	if err != nil {
 		return false, fmt.Errorf("reading ClearBit() row: %v", err)
 	} else if !ok {
-		return false, fmt.Errorf("ClearBit() row field '%v' required", rowLabel)
+		return false, fmt.Errorf("ClearBit() row field '%v' required", DefaultRowLabel)
 	}
 
 	colID, ok, err := c.UintArg(columnLabel)
@@ -1000,14 +994,13 @@ func (e *Executor) executeSetBit(ctx context.Context, index string, c *pql.Call,
 
 	// Retrieve labels.
 	columnLabel := idx.ColumnLabel()
-	rowLabel := f.RowLabel()
 
 	// Read fields using labels.
-	rowID, ok, err := c.UintArg(rowLabel)
+	rowID, ok, err := c.UintArg(DefaultRowLabel)
 	if err != nil {
 		return false, fmt.Errorf("reading SetBit() row: %v", err)
 	} else if !ok {
-		return false, fmt.Errorf("SetBit() row field '%v' required", rowLabel)
+		return false, fmt.Errorf("SetBit() row field '%v' required", DefaultRowLabel)
 	}
 
 	colID, ok, err := c.UintArg(columnLabel)
@@ -1171,20 +1164,19 @@ func (e *Executor) executeSetRowAttrs(ctx context.Context, index string, c *pql.
 	if frame == nil {
 		return ErrFrameNotFound
 	}
-	rowLabel := frame.RowLabel()
 
 	// Parse labels.
-	rowID, ok, err := c.UintArg(rowLabel)
+	rowID, ok, err := c.UintArg(DefaultRowLabel)
 	if err != nil {
 		return fmt.Errorf("reading SetRowAttrs() row: %v", err)
 	} else if !ok {
-		return fmt.Errorf("SetRowAttrs() row field '%v' required", rowLabel)
+		return fmt.Errorf("SetRowAttrs() row field '%v' required", DefaultRowLabel)
 	}
 
 	// Copy args and remove reserved fields.
 	attrs := pql.CopyArgs(c.Args)
 	delete(attrs, "frame")
-	delete(attrs, rowLabel)
+	delete(attrs, DefaultRowLabel)
 
 	// Set attributes.
 	if err := frame.RowAttrStore().SetAttrs(rowID, attrs); err != nil {
@@ -1232,19 +1224,18 @@ func (e *Executor) executeBulkSetRowAttrs(ctx context.Context, index string, cal
 		if f == nil {
 			return nil, ErrFrameNotFound
 		}
-		rowLabel := f.RowLabel()
 
-		rowID, ok, err := c.UintArg(rowLabel)
+		rowID, ok, err := c.UintArg(DefaultRowLabel)
 		if err != nil {
-			return nil, fmt.Errorf("reading SetRowAttrs() row: %v", rowLabel)
+			return nil, fmt.Errorf("reading SetRowAttrs() row: %v", DefaultRowLabel)
 		} else if !ok {
-			return nil, fmt.Errorf("SetRowAttrs row field '%v' required", rowLabel)
+			return nil, fmt.Errorf("SetRowAttrs row field '%v' required", DefaultRowLabel)
 		}
 
 		// Copy args and remove reserved fields.
 		attrs := pql.CopyArgs(c.Args)
 		delete(attrs, "frame")
-		delete(attrs, rowLabel)
+		delete(attrs, DefaultRowLabel)
 
 		// Create frame group, if not exists.
 		frameMap := m[frame]
diff --git a/executor_test.go b/executor_test.go
index c98239137..d90c8048f 100644
--- a/executor_test.go
+++ b/executor_test.go
@@ -42,9 +42,9 @@ func TestExecutor_Execute_Bitmap(t *testing.T) {
 
 		// Set bits.
 		if _, err := e.Execute(context.Background(), "i", test.MustParse(``+
-			fmt.Sprintf("SetBit(frame=f, rowID=%d, columnID=%d)\n", 10, 3)+
-			fmt.Sprintf("SetBit(frame=f, rowID=%d, columnID=%d)\n", 10, SliceWidth+1)+
-			fmt.Sprintf("SetBit(frame=f, rowID=%d, columnID=%d)\n", 20, SliceWidth+1),
+			fmt.Sprintf("SetBit(frame=f, row=%d, columnID=%d)\n", 10, 3)+
+			fmt.Sprintf("SetBit(frame=f, row=%d, columnID=%d)\n", 10, SliceWidth+1)+
+			fmt.Sprintf("SetBit(frame=f, row=%d, columnID=%d)\n", 20, SliceWidth+1),
 		), nil, nil); err != nil {
 			t.Fatal(err)
 		}
@@ -52,7 +52,7 @@ func TestExecutor_Execute_Bitmap(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		if res, err := e.Execute(context.Background(), "i", test.MustParse(`Bitmap(rowID=10, frame=f)`), nil, nil); err != nil {
+		if res, err := e.Execute(context.Background(), "i", test.MustParse(`Bitmap(row=10, frame=f)`), nil, nil); err != nil {
 			t.Fatal(err)
 		} else if bits := res[0].(*pilosa.Bitmap).Bits(); !reflect.DeepEqual(bits, []uint64{3, SliceWidth + 1}) {
 			t.Fatalf("unexpected bits: %+v", bits)
@@ -61,7 +61,7 @@ func TestExecutor_Execute_Bitmap(t *testing.T) {
 		}
 
 		// Inhibit bits.
-		if res, err := e.Execute(context.Background(), "i", test.MustParse(`Bitmap(rowID=10, frame=f)`), nil, &pilosa.ExecOptions{ExcludeBits: true}); err != nil {
+		if res, err := e.Execute(context.Background(), "i", test.MustParse(`Bitmap(row=10, frame=f)`), nil, &pilosa.ExecOptions{ExcludeBits: true}); err != nil {
 			t.Fatal(err)
 		} else if bits := res[0].(*pilosa.Bitmap).Bits(); !reflect.DeepEqual(bits, []uint64{}) {
 			t.Fatalf("unexpected bits: %+v", bits)
@@ -70,7 +70,7 @@ func TestExecutor_Execute_Bitmap(t *testing.T) {
 		}
 
 		// Inhibit attributes.
-		if res, err := e.Execute(context.Background(), "i", test.MustParse(`Bitmap(rowID=10, frame=f)`), nil, &pilosa.ExecOptions{ExcludeAttrs: true}); err != nil {
+		if res, err := e.Execute(context.Background(), "i", test.MustParse(`Bitmap(row=10, frame=f)`), nil, &pilosa.ExecOptions{ExcludeAttrs: true}); err != nil {
 			t.Fatal(err)
 		} else if bits := res[0].(*pilosa.Bitmap).Bits(); !reflect.DeepEqual(bits, []uint64{3, SliceWidth + 1}) {
 			t.Fatalf("unexpected bits: %+v", bits)
@@ -91,9 +91,9 @@ func TestExecutor_Execute_Bitmap(t *testing.T) {
 
 		// Set bits.
 		if _, err := e.Execute(context.Background(), "i", test.MustParse(``+
-			fmt.Sprintf("SetBit(frame=f, rowID=%d, columnID=%d)\n", 10, 3)+
-			fmt.Sprintf("SetBit(frame=f, rowID=%d, columnID=%d)\n", 10, SliceWidth+1)+
-			fmt.Sprintf("SetBit(frame=f, rowID=%d, columnID=%d)\n", 20, SliceWidth+1),
+			fmt.Sprintf("SetBit(frame=f, row=%d, columnID=%d)\n", 10, 3)+
+			fmt.Sprintf("SetBit(frame=f, row=%d, columnID=%d)\n", 10, SliceWidth+1)+
+			fmt.Sprintf("SetBit(frame=f, row=%d, columnID=%d)\n", 20, SliceWidth+1),
 		), nil, nil); err != nil {
 			t.Fatal(err)
 		}
@@ -122,7 +122,7 @@ func TestExecutor_Execute_Difference(t *testing.T) {
 	hldr.MustCreateFragmentIfNotExists("i", "general", pilosa.ViewStandard, 0).MustSetBits(11, 4)
 
 	e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
-	if res, err := e.Execute(context.Background(), "i", test.MustParse(`Difference(Bitmap(rowID=10), Bitmap(rowID=11))`), nil, nil); err != nil {
+	if res, err := e.Execute(context.Background(), "i", test.MustParse(`Difference(Bitmap(row=10), Bitmap(row=11))`), nil, nil); err != nil {
 		t.Fatal(err)
 	} else if bits := res[0].(*pilosa.Bitmap).Bits(); !reflect.DeepEqual(bits, []uint64{1, 3}) {
 		t.Fatalf("unexpected bits: %+v", bits)
@@ -154,7 +154,7 @@ func TestExecutor_Execute_Intersect(t *testing.T) {
 	hldr.MustCreateFragmentIfNotExists("i", "general", pilosa.ViewStandard, 1).MustSetBits(11, SliceWidth+2)
 
 	e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
-	if res, err := e.Execute(context.Background(), "i", test.MustParse(`Intersect(Bitmap(rowID=10), Bitmap(rowID=11))`), nil, nil); err != nil {
+	if res, err := e.Execute(context.Background(), "i", test.MustParse(`Intersect(Bitmap(row=10), Bitmap(row=11))`), nil, nil); err != nil {
 		t.Fatal(err)
 	} else if bits := res[0].(*pilosa.Bitmap).Bits(); !reflect.DeepEqual(bits, []uint64{1, SliceWidth + 2}) {
 		t.Fatalf("unexpected bits: %+v", bits)
@@ -184,7 +184,7 @@ func TestExecutor_Execute_Union(t *testing.T) {
 	hldr.MustCreateFragmentIfNotExists("i", "general", pilosa.ViewStandard, 1).MustSetBits(11, SliceWidth+2)
 
 	e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
-	if res, err := e.Execute(context.Background(), "i", test.MustParse(`Union(Bitmap(rowID=10), Bitmap(rowID=11))`), nil, nil); err != nil {
+	if res, err := e.Execute(context.Background(), "i", test.MustParse(`Union(Bitmap(row=10), Bitmap(row=11))`), nil, nil); err != nil {
 		t.Fatal(err)
 	} else if bits := res[0].(*pilosa.Bitmap).Bits(); !reflect.DeepEqual(bits, []uint64{0, 2, SliceWidth + 1, SliceWidth + 2}) {
 		t.Fatalf("unexpected bits: %+v", bits)
@@ -217,7 +217,7 @@ func TestExecutor_Execute_Xor(t *testing.T) {
 	hldr.MustCreateFragmentIfNotExists("i", "general", pilosa.ViewStandard, 1).MustSetBits(11, SliceWidth+2)
 
 	e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
-	if res, err := e.Execute(context.Background(), "i", test.MustParse(`Xor(Bitmap(rowID=10), Bitmap(rowID=11))`), nil, nil); err != nil {
+	if res, err := e.Execute(context.Background(), "i", test.MustParse(`Xor(Bitmap(row=10), Bitmap(row=11))`), nil, nil); err != nil {
 		t.Fatal(err)
 	} else if bits := res[0].(*pilosa.Bitmap).Bits(); !reflect.DeepEqual(bits, []uint64{0, 2, SliceWidth + 1}) {
 		t.Fatalf("unexpected bits: %+v", bits)
@@ -233,7 +233,7 @@ func TestExecutor_Execute_Count(t *testing.T) {
 	hldr.MustCreateFragmentIfNotExists("i", "f", pilosa.ViewStandard, 1).MustSetBits(10, SliceWidth+2)
 
 	e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
-	if res, err := e.Execute(context.Background(), "i", test.MustParse(`Count(Bitmap(rowID=10, frame=f))`), nil, nil); err != nil {
+	if res, err := e.Execute(context.Background(), "i", test.MustParse(`Count(Bitmap(row=10, frame=f))`), nil, nil); err != nil {
 		t.Fatal(err)
 	} else if res[0] != uint64(3) {
 		t.Fatalf("unexpected n: %d", res[0])
@@ -251,7 +251,7 @@ func TestExecutor_Execute_SetBit(t *testing.T) {
 		t.Fatalf("unexpected bitmap count: %d", n)
 	}
 
-	if res, err := e.Execute(context.Background(), "i", test.MustParse(`SetBit(rowID=11, frame=f, columnID=1)`), nil, nil); err != nil {
+	if res, err := e.Execute(context.Background(), "i", test.MustParse(`SetBit(row=11, frame=f, columnID=1)`), nil, nil); err != nil {
 		t.Fatal(err)
 	} else {
 		if !res[0].(bool) {
@@ -262,7 +262,7 @@ func TestExecutor_Execute_SetBit(t *testing.T) {
 	if n := f.Row(11).Count(); n != 1 {
 		t.Fatalf("unexpected bitmap count: %d", n)
 	}
-	if res, err := e.Execute(context.Background(), "i", test.MustParse(`SetBit(rowID=11, frame=f, columnID=1)`), nil, nil); err != nil {
+	if res, err := e.Execute(context.Background(), "i", test.MustParse(`SetBit(row=11, frame=f, columnID=1)`), nil, nil); err != nil {
 		t.Fatal(err)
 	} else {
 		if res[0].(bool) {
@@ -384,16 +384,16 @@ func TestExecutor_Execute_SetRowAttrs(t *testing.T) {
 	// Set two fields on f/10.
 	// Also set fields on other bitmaps and frames to test isolation.
 	e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
-	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetRowAttrs(rowID=10, frame=f, foo="bar")`), nil, nil); err != nil {
+	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetRowAttrs(row=10, frame=f, foo="bar")`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
-	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetRowAttrs(rowID=200, frame=f, YYY=1)`), nil, nil); err != nil {
+	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetRowAttrs(row=200, frame=f, YYY=1)`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
-	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetRowAttrs(rowID=10, frame=xxx, YYY=1)`), nil, nil); err != nil {
+	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetRowAttrs(row=10, frame=xxx, YYY=1)`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
-	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetRowAttrs(rowID=10, frame=f, baz=123, bat=true)`), nil, nil); err != nil {
+	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetRowAttrs(row=10, frame=f, baz=123, bat=true)`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
 
@@ -419,15 +419,15 @@ func TestExecutor_Execute_TopN(t *testing.T) {
 	} else if _, err := idx.CreateFrame("other", pilosa.FrameOptions{InverseEnabled: true}); err != nil {
 		t.Fatal(err)
 	} else if _, err := e.Execute(context.Background(), "i", test.MustParse(`
-		SetBit(frame=f, rowID=0, columnID=0)
-		SetBit(frame=f, rowID=0, columnID=1)
-		SetBit(frame=f, rowID=0, columnID=`+strconv.Itoa(SliceWidth)+`)
-		SetBit(frame=f, rowID=0, columnID=`+strconv.Itoa(SliceWidth+2)+`)
-		SetBit(frame=f, rowID=0, columnID=`+strconv.Itoa((5*SliceWidth)+100)+`)
-		SetBit(frame=f, rowID=10, columnID=0)
-		SetBit(frame=f, rowID=10, columnID=`+strconv.Itoa(SliceWidth)+`)
-		SetBit(frame=f, rowID=20, columnID=`+strconv.Itoa(SliceWidth)+`)
-		SetBit(frame=other, rowID=0, columnID=0)
+		SetBit(frame=f, row=0, columnID=0)
+		SetBit(frame=f, row=0, columnID=1)
+		SetBit(frame=f, row=0, columnID=`+strconv.Itoa(SliceWidth)+`)
+		SetBit(frame=f, row=0, columnID=`+strconv.Itoa(SliceWidth+2)+`)
+		SetBit(frame=f, row=0, columnID=`+strconv.Itoa((5*SliceWidth)+100)+`)
+		SetBit(frame=f, row=10, columnID=0)
+		SetBit(frame=f, row=10, columnID=`+strconv.Itoa(SliceWidth)+`)
+		SetBit(frame=f, row=20, columnID=`+strconv.Itoa(SliceWidth)+`)
+		SetBit(frame=other, row=0, columnID=0)
 	`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
@@ -543,7 +543,7 @@ func TestExecutor_Execute_TopN_Src(t *testing.T) {
 
 	// Execute query.
 	e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
-	if result, err := e.Execute(context.Background(), "i", test.MustParse(`TopN(Bitmap(rowID=100, frame=other), frame=f, n=3)`), nil, nil); err != nil {
+	if result, err := e.Execute(context.Background(), "i", test.MustParse(`TopN(Bitmap(row=100, frame=other), frame=f, n=3)`), nil, nil); err != nil {
 		t.Fatal(err)
 	} else if !reflect.DeepEqual(result, []interface{}{[]pilosa.Pair{
 		{ID: 20, Count: 3},
@@ -590,7 +590,7 @@ func TestExecutor_Execute_TopN_Attr_Src(t *testing.T) {
 		t.Fatal(err)
 	}
 	e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
-	if result, err := e.Execute(context.Background(), "i", test.MustParse(`TopN(Bitmap(rowID=10,frame=f),frame="f", n=1, field="category", filters=[123])`), nil, nil); err != nil {
+	if result, err := e.Execute(context.Background(), "i", test.MustParse(`TopN(Bitmap(row=10,frame=f),frame="f", n=1, field="category", filters=[123])`), nil, nil); err != nil {
 		t.Fatal(err)
 	} else if !reflect.DeepEqual(result, []interface{}{[]pilosa.Pair{
 		{ID: 10, Count: 1},
@@ -630,8 +630,8 @@ func TestExecutor_Execute_Sum(t *testing.T) {
 	}
 
 	if _, err := e.Execute(context.Background(), "i", test.MustParse(`
-		SetBit(frame=f, rowID=0, columnID=0)
-		SetBit(frame=f, rowID=0, columnID=`+strconv.Itoa(SliceWidth+1)+`)
+		SetBit(frame=f, row=0, columnID=0)
+		SetBit(frame=f, row=0, columnID=`+strconv.Itoa(SliceWidth+1)+`)
 
 		SetFieldValue(frame=f, foo=20, bar=2000, columnID=0)
 		SetFieldValue(frame=f, foo=30, columnID=`+strconv.Itoa(SliceWidth)+`)
@@ -652,7 +652,7 @@ func TestExecutor_Execute_Sum(t *testing.T) {
 	})
 
 	t.Run("WithFilter", func(t *testing.T) {
-		if result, err := e.Execute(context.Background(), "i", test.MustParse(`Sum(Bitmap(frame=f, rowID=0), frame=f, field=foo)`), nil, nil); err != nil {
+		if result, err := e.Execute(context.Background(), "i", test.MustParse(`Sum(Bitmap(frame=f, row=0), frame=f, field=foo)`), nil, nil); err != nil {
 			t.Fatal(err)
 		} else if !reflect.DeepEqual(result[0], pilosa.SumCount{Sum: 80, Count: 2}) {
 			t.Fatalf("unexpected result: %s", spew.Sdump(result))
@@ -679,22 +679,22 @@ func TestExecutor_Execute_Range(t *testing.T) {
 
 	// Set bits.
 	if _, err := e.Execute(context.Background(), "i", test.MustParse(`
-        SetBit(frame=f, rowID=1, columnID=2, timestamp="1999-12-31T00:00")
-        SetBit(frame=f, rowID=1, columnID=3, timestamp="2000-01-01T00:00")
-        SetBit(frame=f, rowID=1, columnID=4, timestamp="2000-01-02T00:00")
-        SetBit(frame=f, rowID=1, columnID=5, timestamp="2000-02-01T00:00")
-        SetBit(frame=f, rowID=1, columnID=6, timestamp="2001-01-01T00:00")
-        SetBit(frame=f, rowID=1, columnID=7, timestamp="2002-01-01T02:00")
+        SetBit(frame=f, row=1, columnID=2, timestamp="1999-12-31T00:00")
+        SetBit(frame=f, row=1, columnID=3, timestamp="2000-01-01T00:00")
+        SetBit(frame=f, row=1, columnID=4, timestamp="2000-01-02T00:00")
+        SetBit(frame=f, row=1, columnID=5, timestamp="2000-02-01T00:00")
+        SetBit(frame=f, row=1, columnID=6, timestamp="2001-01-01T00:00")
+        SetBit(frame=f, row=1, columnID=7, timestamp="2002-01-01T02:00")
 
-        SetBit(frame=f, rowID=1, columnID=2, timestamp="1999-12-30T00:00")
-        SetBit(frame=f, rowID=1, columnID=2, timestamp="2002-02-01T00:00")
-        SetBit(frame=f, rowID=10, columnID=2, timestamp="2001-01-01T00:00")
+        SetBit(frame=f, row=1, columnID=2, timestamp="1999-12-30T00:00")
+        SetBit(frame=f, row=1, columnID=2, timestamp="2002-02-01T00:00")
+        SetBit(frame=f, row=10, columnID=2, timestamp="2001-01-01T00:00")
 	`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
 
 	t.Run("Standard", func(t *testing.T) {
-		if res, err := e.Execute(context.Background(), "i", test.MustParse(`Range(rowID=1, frame=f, start="1999-12-31T00:00", end="2002-01-01T03:00")`), nil, nil); err != nil {
+		if res, err := e.Execute(context.Background(), "i", test.MustParse(`Range(row=1, frame=f, start="1999-12-31T00:00", end="2002-01-01T03:00")`), nil, nil); err != nil {
 			t.Fatal(err)
 		} else if bits := res[0].(*pilosa.Bitmap).Bits(); !reflect.DeepEqual(bits, []uint64{2, 3, 4, 5, 6, 7}) {
 			t.Fatalf("unexpected bits: %+v", bits)
@@ -751,8 +751,8 @@ func TestExecutor_Execute_FieldRange(t *testing.T) {
 	}
 
 	if _, err := e.Execute(context.Background(), "i", test.MustParse(`
-		SetBit(frame=f, rowID=0, columnID=0)
-		SetBit(frame=f, rowID=0, columnID=`+strconv.Itoa(SliceWidth+1)+`)
+		SetBit(frame=f, row=0, columnID=0)
+		SetBit(frame=f, row=0, columnID=`+strconv.Itoa(SliceWidth+1)+`)
 
 		SetFieldValue(frame=f, foo=20, bar=2000, columnID=50)
 		SetFieldValue(frame=f, foo=30, columnID=`+strconv.Itoa(SliceWidth)+`)
@@ -908,7 +908,7 @@ func TestExecutor_Execute_Remote_Bitmap(t *testing.T) {
 	s.Handler.Executor.ExecuteFn = func(ctx context.Context, index string, query *pql.Query, slices []uint64, opt *pilosa.ExecOptions) ([]interface{}, error) {
 		if index != "i" {
 			t.Fatalf("unexpected index: %s", index)
-		} else if query.String() != `Bitmap(frame="f", rowID=10)` {
+		} else if query.String() != `Bitmap(frame="f", row=10)` {
 			t.Fatalf("unexpected query: %s", query.String())
 		} else if !reflect.DeepEqual(slices, []uint64{1}) {
 			t.Fatalf("unexpected slices: %+v", slices)
@@ -931,7 +931,7 @@ func TestExecutor_Execute_Remote_Bitmap(t *testing.T) {
 	hldr.MustCreateFragmentIfNotExists("i", "f", pilosa.ViewStandard, 1).MustSetBits(10, (1*SliceWidth)+1)
 
 	e := test.NewExecutor(hldr.Holder, c)
-	if res, err := e.Execute(context.Background(), "i", test.MustParse(`Bitmap(rowID=10, frame=f)`), nil, nil); err != nil {
+	if res, err := e.Execute(context.Background(), "i", test.MustParse(`Bitmap(row=10, frame=f)`), nil, nil); err != nil {
 		t.Fatal(err)
 	} else if bits := res[0].(*pilosa.Bitmap).Bits(); !reflect.DeepEqual(bits, []uint64{1, 2, 2*SliceWidth + 4}) {
 		t.Fatalf("unexpected bits: %+v", bits)
@@ -966,7 +966,7 @@ func TestExecutor_Execute_Remote_Count(t *testing.T) {
 	hldr.MustCreateFragmentIfNotExists("i", "f", pilosa.ViewStandard, 2).MustSetBits(10, (2*SliceWidth)+2)
 
 	e := test.NewExecutor(hldr.Holder, c)
-	if res, err := e.Execute(context.Background(), "i", test.MustParse(`Count(Bitmap(rowID=10, frame=f))`), nil, nil); err != nil {
+	if res, err := e.Execute(context.Background(), "i", test.MustParse(`Count(Bitmap(row=10, frame=f))`), nil, nil); err != nil {
 		t.Fatal(err)
 	} else if res[0] != uint64(12) {
 		t.Fatalf("unexpected n: %d", res[0])
@@ -994,7 +994,7 @@ func TestExecutor_Execute_Remote_SetBit(t *testing.T) {
 	s.Handler.Executor.ExecuteFn = func(ctx context.Context, index string, query *pql.Query, slices []uint64, opt *pilosa.ExecOptions) ([]interface{}, error) {
 		if index != `i` {
 			t.Fatalf("unexpected index: %s", index)
-		} else if query.String() != `SetBit(columnID=2, frame="f", rowID=10)` {
+		} else if query.String() != `SetBit(columnID=2, frame="f", row=10)` {
 			t.Fatalf("unexpected query: %s", query.String())
 		}
 		remoteCalled = true
@@ -1012,7 +1012,7 @@ func TestExecutor_Execute_Remote_SetBit(t *testing.T) {
 	}
 
 	e := test.NewExecutor(hldr.Holder, c)
-	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetBit(rowID=10, frame=f, columnID=2)`), nil, nil); err != nil {
+	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetBit(row=10, frame=f, columnID=2)`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
 
@@ -1046,7 +1046,7 @@ func TestExecutor_Execute_Remote_SetBit_With_Timestamp(t *testing.T) {
 	s.Handler.Executor.ExecuteFn = func(ctx context.Context, index string, query *pql.Query, slices []uint64, opt *pilosa.ExecOptions) ([]interface{}, error) {
 		if index != `i` {
 			t.Fatalf("unexpected index: %s", index)
-		} else if query.String() != `SetBit(columnID=2, frame="f", rowID=10, timestamp="2016-12-11T10:09")` {
+		} else if query.String() != `SetBit(columnID=2, frame="f", row=10, timestamp="2016-12-11T10:09")` {
 			t.Fatalf("unexpected query: %s", query.String())
 		}
 		remoteCalled = true
@@ -1066,7 +1066,7 @@ func TestExecutor_Execute_Remote_SetBit_With_Timestamp(t *testing.T) {
 	}
 
 	e := test.NewExecutor(hldr.Holder, c)
-	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetBit(rowID=10, frame=f, columnID=2, timestamp="2016-12-11T10:09")`), nil, nil); err != nil {
+	if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetBit(row=10, frame=f, columnID=2, timestamp="2016-12-11T10:09")`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
 
@@ -1169,7 +1169,7 @@ func TestExectutor_SetColumnAttrs_ExcludeFrame(t *testing.T) {
 	e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
 
 	// SetColumnAttrs call should exclude the frame attribute
-	_, err := e.Execute(context.Background(), "i", test.MustParse("SetBit(frame='f', rowID=1, columnID=10)"), nil, nil)
+	_, err := e.Execute(context.Background(), "i", test.MustParse("SetBit(frame='f', row=1, columnID=10)"), nil, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1186,7 +1186,7 @@ func TestExectutor_SetColumnAttrs_ExcludeFrame(t *testing.T) {
 	}
 
 	// SetColumnAttrs call should not break if frame is not specified
-	_, err = e.Execute(context.Background(), "i", test.MustParse("SetBit(frame='f', rowID=1, columnID=20)"), nil, nil)
+	_, err = e.Execute(context.Background(), "i", test.MustParse("SetBit(frame='f', row=1, columnID=20)"), nil, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/fragment.go b/fragment.go
index ab397af47..8b32182d6 100644
--- a/fragment.go
+++ b/fragment.go
@@ -1841,11 +1841,11 @@ func (s *FragmentSyncer) syncBlock(id int) error {
 
 		// Only sync the standard block.
 		for j := 0; j < len(set.ColumnIDs); j++ {
-			fmt.Fprintf(&(buffers[count/s.Cluster.MaxWritesPerRequest]), "SetBit(frame=%q, rowID=%d, columnID=%d)\n", f.Frame(), set.RowIDs[j], (f.Slice()*SliceWidth)+set.ColumnIDs[j])
+			fmt.Fprintf(&(buffers[count/s.Cluster.MaxWritesPerRequest]), "SetBit(frame=%q, row=%d, columnID=%d)\n", f.Frame(), set.RowIDs[j], (f.Slice()*SliceWidth)+set.ColumnIDs[j])
 			count++
 		}
 		for j := 0; j < len(clear.ColumnIDs); j++ {
-			fmt.Fprintf(&(buffers[count/s.Cluster.MaxWritesPerRequest]), "ClearBit(frame=%q, rowID=%d, columnID=%d)\n", f.Frame(), clear.RowIDs[j], (f.Slice()*SliceWidth)+clear.ColumnIDs[j])
+			fmt.Fprintf(&(buffers[count/s.Cluster.MaxWritesPerRequest]), "ClearBit(frame=%q, row=%d, columnID=%d)\n", f.Frame(), clear.RowIDs[j], (f.Slice()*SliceWidth)+clear.ColumnIDs[j])
 			count++
 		}
 
diff --git a/frame.go b/frame.go
index 466d7ae96..060125385 100644
--- a/frame.go
+++ b/frame.go
@@ -32,7 +32,7 @@ import (
 
 // Default frame settings.
 const (
-	DefaultRowLabel       = "rowID"
+	DefaultRowLabel       = "row"
 	DefaultCacheType      = CacheTypeRanked
 	DefaultInverseEnabled = false
 	DefaultRangeEnabled   = false
@@ -87,7 +87,6 @@ func NewFrame(path, index, name string) (*Frame, error) {
 		broadcaster: NopBroadcaster,
 		Stats:       NopStatsClient,
 
-		rowLabel:       DefaultRowLabel,
 		inverseEnabled: DefaultInverseEnabled,
 		cacheType:      DefaultCacheType,
 		cacheSize:      DefaultCacheSize,
@@ -139,39 +138,6 @@ func (f *Frame) MaxInverseSlice() uint64 {
 	return view.MaxSlice()
 }
 
-// SetRowLabel sets the row labels. Persists to meta file on update.
-func (f *Frame) SetRowLabel(v string) error {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-
-	// Ignore if no change occurred.
-	if v == "" || f.rowLabel == v {
-		return nil
-	}
-
-	// Make sure rowLabel is valid name
-	err := ValidateLabel(v)
-	if err != nil {
-		return err
-	}
-
-	// Persist meta data to disk on change.
-	f.rowLabel = v
-	if err := f.saveMeta(); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// RowLabel returns the row label.
-func (f *Frame) RowLabel() string {
-	f.mu.RLock()
-	v := f.rowLabel
-	f.mu.RUnlock()
-	return v
-}
-
 // CacheType returns the caching mode for the frame.
 func (f *Frame) CacheType() string {
 	return f.cacheType
@@ -224,7 +190,6 @@ func (f *Frame) Options() FrameOptions {
 
 func (f *Frame) options() FrameOptions {
 	return FrameOptions{
-		RowLabel:       f.rowLabel,
 		InverseEnabled: f.inverseEnabled,
 		RangeEnabled:   f.rangeEnabled,
 		CacheType:      f.cacheType,
@@ -319,7 +284,6 @@ func (f *Frame) loadMeta() error {
 	}
 
 	// Copy metadata fields.
-	f.rowLabel = pb.RowLabel
 	f.inverseEnabled = pb.InverseEnabled
 	f.cacheType = pb.CacheType
 	if f.cacheType == "" {
@@ -1030,7 +994,6 @@ func (p frameInfoSlice) Less(i, j int) bool { return p[i].Name < p[j].Name }
 
 // FrameOptions represents options to set when initializing a frame.
 type FrameOptions struct {
-	RowLabel       string      `json:"rowLabel,omitempty"`
 	InverseEnabled bool        `json:"inverseEnabled,omitempty"`
 	RangeEnabled   bool        `json:"rangeEnabled,omitempty"`
 	CacheType      string      `json:"cacheType,omitempty"`
@@ -1049,7 +1012,6 @@ func encodeFrameOptions(o *FrameOptions) *internal.FrameMeta {
 		return nil
 	}
 	return &internal.FrameMeta{
-		RowLabel:       o.RowLabel,
 		InverseEnabled: o.InverseEnabled,
 		RangeEnabled:   o.RangeEnabled,
 		CacheType:      o.CacheType,
@@ -1064,7 +1026,6 @@ func decodeFrameOptions(options *internal.FrameMeta) *FrameOptions {
 		return nil
 	}
 	return &FrameOptions{
-		RowLabel:       options.RowLabel,
 		InverseEnabled: options.InverseEnabled,
 		RangeEnabled:   options.RangeEnabled,
 		CacheType:      options.CacheType,
diff --git a/frame_test.go b/frame_test.go
index 6e4ade84a..2107bd703 100644
--- a/frame_test.go
+++ b/frame_test.go
@@ -267,49 +267,6 @@ func TestFrame_NameValidation(t *testing.T) {
 	}
 }
 
-// Ensure that frame RowLable validation is consistent.
-func TestFrame_RowLabelValidation(t *testing.T) {
-	validRowLabels := []string{
-		"",
-		"foo",
-		"hyphen-ated",
-		"under_score",
-		"abc123",
-		"trailing_",
-		"camelCase",
-		"UPPERCASE",
-	}
-	invalidRowLabels := []string{
-		"123abc",
-		"x.y",
-		"_foo",
-		"-bar",
-		"abc def",
-		"a12345678901234567890123456789012345678901234567890123456789012345",
-	}
-
-	path, err := ioutil.TempDir("", "pilosa-frame-")
-	if err != nil {
-		panic(err)
-	}
-	f, err := pilosa.NewFrame(path, "i", "f")
-	if err != nil {
-		t.Fatalf("unexpected frame error: %s", err)
-	}
-
-	for _, label := range validRowLabels {
-		if err := f.SetRowLabel(label); err != nil {
-			t.Fatalf("unexpected row label: %s %s", label, err)
-		}
-	}
-	for _, label := range invalidRowLabels {
-		if err := f.SetRowLabel(label); err == nil {
-			t.Fatalf("expected error on row label: %s", label)
-		}
-	}
-
-}
-
 // Ensure frame can open and retrieve a view.
 func TestFrame_DeleteView(t *testing.T) {
 	f := test.MustOpenFrame()
diff --git a/handler_internal_test.go b/handler_internal_test.go
index 169267c38..fb6226ea9 100644
--- a/handler_internal_test.go
+++ b/handler_internal_test.go
@@ -66,11 +66,10 @@ func TestPostFrameRequestUnmarshalJSON(t *testing.T) {
 		{json: `{"options": {}}`, expected: postFrameRequest{Options: FrameOptions{}}},
 		{json: `{"options": 4}`, err: "options is not map[string]interface{}"},
 		{json: `{"option": {}}`, err: "Unknown key: option:map[]"},
-		{json: `{"options": {"rowLabel": "test"}}`, expected: postFrameRequest{Options: FrameOptions{RowLabel: "test"}}},
-		{json: `{"options": {"rowLabl": "test"}}`, err: "Unknown key: rowLabl:test"},
-		{json: `{"options": {"rowLabel": "test", "inverseEnabled": true}}`, expected: postFrameRequest{Options: FrameOptions{RowLabel: "test", InverseEnabled: true}}},
-		{json: `{"options": {"rowLabel": "test", "inverseEnabled": true, "cacheType": "type"}}`, expected: postFrameRequest{Options: FrameOptions{RowLabel: "test", InverseEnabled: true, CacheType: "type"}}},
-		{json: `{"options": {"rowLabel": "test", "inverse": true, "cacheType": "type"}}`, err: "Unknown key: inverse:true"},
+		{json: `{"options": {"rowLabel": "test"}}`, err: "Unknown key: rowLabel:test"},
+		{json: `{"options": {"inverseEnabled": true}}`, expected: postFrameRequest{Options: FrameOptions{InverseEnabled: true}}},
+		{json: `{"options": {"inverseEnabled": true, "cacheType": "type"}}`, expected: postFrameRequest{Options: FrameOptions{InverseEnabled: true, CacheType: "type"}}},
+		{json: `{"options": {"inverse": true, "cacheType": "type"}}`, err: "Unknown key: inverse:true"},
 	}
 	for _, test := range tests {
 		actual := &postFrameRequest{}
diff --git a/handler_test.go b/handler_test.go
index 551c81d66..3c9c08094 100644
--- a/handler_test.go
+++ b/handler_test.go
@@ -1433,7 +1433,7 @@ func TestHandler_DeleteInputDefinition(t *testing.T) {
 
 	// Test input definition is deleted.
 	index := hldr.MustCreateIndexIfNotExists("i0", pilosa.IndexOptions{})
-	frames := internal.Frame{Name: "f", Meta: &internal.FrameMeta{RowLabel: "row"}}
+	frames := internal.Frame{Name: "f", Meta: &internal.FrameMeta{}}
 	action := internal.InputDefinitionAction{Frame: "f", ValueDestination: "mapping", ValueMap: map[string]uint64{"Green": 1}}
 	fields := internal.InputDefinitionField{Name: "id", PrimaryKey: true, InputDefinitionActions: []*internal.InputDefinitionAction{&action}}
 	def := internal.InputDefinition{Name: "test", Frames: []*internal.Frame{&frames}, Fields: []*internal.InputDefinitionField{&fields}}
@@ -1470,7 +1470,7 @@ func TestHandler_GetInputDefinition(t *testing.T) {
 	h.Holder = hldr.Holder
 	h.Cluster = test.NewCluster(1)
 
-	frames := internal.Frame{Name: "f", Meta: &internal.FrameMeta{RowLabel: "row"}}
+	frames := internal.Frame{Name: "f", Meta: &internal.FrameMeta{}}
 	action := internal.InputDefinitionAction{Frame: "f", ValueDestination: "mapping", ValueMap: map[string]uint64{"Green": 1}}
 	fields := internal.InputDefinitionField{Name: "id", PrimaryKey: true, InputDefinitionActions: []*internal.InputDefinitionAction{&action}}
 	def := internal.InputDefinition{Name: "test", Frames: []*internal.Frame{&frames}, Fields: []*internal.InputDefinitionField{&fields}}
diff --git a/index.go b/index.go
index 707b87213..968bac847 100644
--- a/index.go
+++ b/index.go
@@ -446,11 +446,6 @@ func (i *Index) createFrame(name string, opt FrameOptions) (*Frame, error) {
 		return nil, ErrInvalidCacheType
 	}
 
-	// Validate that row label does not match column label.
-	if i.columnLabel == opt.RowLabel || (opt.RowLabel == "" && i.columnLabel == DefaultRowLabel) {
-		return nil, ErrColumnRowLabelEqual
-	}
-
 	// Validate mutually exclusive options if ranges are enabled.
 	if opt.RangeEnabled {
 		if opt.InverseEnabled {
@@ -496,10 +491,6 @@ func (i *Index) createFrame(name string, opt FrameOptions) (*Frame, error) {
 	}
 	f.cacheType = opt.CacheType
 
-	// Set options.
-	if opt.RowLabel != "" {
-		f.rowLabel = opt.RowLabel
-	}
 	if opt.CacheSize != 0 {
 		f.cacheSize = opt.CacheSize
 	}
@@ -694,7 +685,6 @@ func (i *Index) createInputDefinition(pb *internal.InputDefinition) (*InputDefin
 	for _, fr := range pb.Frames {
 		opt := FrameOptions{
 			// Deprecating row labels per #810. So, setting the default row label here.
-			RowLabel:       DefaultRowLabel,
 			InverseEnabled: fr.Meta.InverseEnabled,
 			CacheType:      fr.Meta.CacheType,
 			CacheSize:      fr.Meta.CacheSize,
diff --git a/index_test.go b/index_test.go
index 23a820f2d..c8cd238e8 100644
--- a/index_test.go
+++ b/index_test.go
@@ -215,32 +215,6 @@ func TestIndex_CreateFrame(t *testing.T) {
 			}
 		})
 	})
-
-	// Ensure frame cannot be created with a matching row label.
-	t.Run("ErrColumnRowLabelEqual", func(t *testing.T) {
-		t.Run("Explicit", func(t *testing.T) {
-			index := test.MustOpenIndex()
-			defer index.Close()
-
-			_, err := index.CreateFrame("f", pilosa.FrameOptions{RowLabel: pilosa.DefaultColumnLabel})
-			if err != pilosa.ErrColumnRowLabelEqual {
-				t.Fatalf("unexpected error: %s", err)
-			}
-		})
-
-		t.Run("Default", func(t *testing.T) {
-			index := test.MustOpenIndex()
-			defer index.Close()
-			if err := index.SetColumnLabel(pilosa.DefaultRowLabel); err != nil {
-				t.Fatal(err)
-			}
-
-			_, err := index.CreateFrame("f", pilosa.FrameOptions{})
-			if err != pilosa.ErrColumnRowLabelEqual {
-				t.Fatalf("unexpected error: %s", err)
-			}
-		})
-	})
 }
 
 // Ensure index can delete a frame.
@@ -303,7 +277,7 @@ func TestIndex_CreateInputDefinition(t *testing.T) {
 	defer index.Close()
 
 	// Create Input Definition.
-	frames := internal.Frame{Name: "f", Meta: &internal.FrameMeta{RowLabel: "row"}}
+	frames := internal.Frame{Name: "f", Meta: &internal.FrameMeta{}}
 	action := internal.InputDefinitionAction{Frame: "f", ValueDestination: "mapping", ValueMap: map[string]uint64{"Green": 1}}
 	field := internal.InputDefinitionField{Name: "id", PrimaryKey: true, InputDefinitionActions: []*internal.InputDefinitionAction{&action}}
 	def := internal.InputDefinition{Name: "test", Frames: []*internal.Frame{&frames}, Fields: []*internal.InputDefinitionField{&field}}
@@ -330,7 +304,7 @@ func TestIndex_CreateExistingInputDefinition(t *testing.T) {
 	}
 
 	// Create Input Definition.
-	frames := internal.Frame{Name: "f", Meta: &internal.FrameMeta{RowLabel: "row"}}
+	frames := internal.Frame{Name: "f", Meta: &internal.FrameMeta{}}
 	action := internal.InputDefinitionAction{Frame: "f", ValueDestination: "mapping", ValueMap: map[string]uint64{"Green": 1}}
 	fields := internal.InputDefinitionField{Name: "id", PrimaryKey: true, InputDefinitionActions: []*internal.InputDefinitionAction{&action}}
 	def = internal.InputDefinition{Name: "test", Frames: []*internal.Frame{&frames}, Fields: []*internal.InputDefinitionField{&fields}}
@@ -350,7 +324,7 @@ func TestIndex_DeleteInputDefinition(t *testing.T) {
 	defer index.Close()
 
 	// Create Input Definition.
-	frames := internal.Frame{Name: "f", Meta: &internal.FrameMeta{RowLabel: "row"}}
+	frames := internal.Frame{Name: "f", Meta: &internal.FrameMeta{}}
 	action := internal.InputDefinitionAction{Frame: "f", ValueDestination: "mapping", ValueMap: map[string]uint64{"Green": 1}}
 	fields := internal.InputDefinitionField{Name: "id", PrimaryKey: true, InputDefinitionActions: []*internal.InputDefinitionAction{&action}}
 	def := internal.InputDefinition{Name: "test", Frames: []*internal.Frame{&frames}, Fields: []*internal.InputDefinitionField{&fields}}
@@ -381,7 +355,7 @@ func TestIndex_CreateFrameWhenOpenInputDefinition(t *testing.T) {
 	defer index.Close()
 
 	// Create Input Definition.
-	frames := internal.Frame{Name: "f", Meta: &internal.FrameMeta{RowLabel: "row"}}
+	frames := internal.Frame{Name: "f", Meta: &internal.FrameMeta{}}
 	action := internal.InputDefinitionAction{Frame: "f", ValueDestination: "mapping", ValueMap: map[string]uint64{"Green": 1}}
 	fields := internal.InputDefinitionField{Name: "id", PrimaryKey: true, InputDefinitionActions: []*internal.InputDefinitionAction{&action}}
 	def := internal.InputDefinition{Name: "test", Frames: []*internal.Frame{&frames}, Fields: []*internal.InputDefinitionField{&fields}}
diff --git a/input_definition_test.go b/input_definition_test.go
index 93d0e393d..efd13bec3 100644
--- a/input_definition_test.go
+++ b/input_definition_test.go
@@ -30,7 +30,7 @@ func TestInputDefinition_Open(t *testing.T) {
 	defer index.Close()
 
 	// Create Input Definition.
-	frames := internal.Frame{Name: "f", Meta: &internal.FrameMeta{RowLabel: "row"}}
+	frames := internal.Frame{Name: "f", Meta: &internal.FrameMeta{}}
 	action := internal.InputDefinitionAction{Frame: "f", ValueDestination: "mapping", ValueMap: map[string]uint64{"Green": 1}}
 	fields := internal.InputDefinitionField{Name: "id", PrimaryKey: true, InputDefinitionActions: []*internal.InputDefinitionAction{&action}}
 	def := internal.InputDefinition{Name: "^", Frames: []*internal.Frame{&frames}, Fields: []*internal.InputDefinitionField{&fields}}
@@ -115,14 +115,14 @@ func TestActionValidation(t *testing.T) {
 		t.Fatalf("Expect error: %s, actual err: %s", pilosa.ErrInputDefinitionAttrsRequired, err)
 	}
 
-	frame := pilosa.InputFrame{Name: "f", Options: pilosa.FrameOptions{RowLabel: "row"}}
+	frame := pilosa.InputFrame{Name: "f", Options: pilosa.FrameOptions{}}
 	info = pilosa.InputDefinitionInfo{Frames: []pilosa.InputFrame{frame}, Fields: []pilosa.InputDefinitionField{field}}
 	err = info.Validate()
 	if !strings.Contains(err.Error(), "rowID required for single-row-boolean") {
 		t.Fatalf("Expected rowID required for single-row-boolean error, actual error: %s", err)
 	}
 
-	frame = pilosa.InputFrame{Name: "^", Options: pilosa.FrameOptions{RowLabel: "row"}}
+	frame = pilosa.InputFrame{Name: "^", Options: pilosa.FrameOptions{}}
 	action = pilosa.Action{Frame: "f", ValueDestination: pilosa.InputSingleRowBool, RowID: &rowID}
 	field = pilosa.InputDefinitionField{Name: "id", PrimaryKey: true, Actions: []pilosa.Action{action}}
 	info = pilosa.InputDefinitionInfo{Frames: []pilosa.InputFrame{frame}, Fields: []pilosa.InputDefinitionField{field}}
@@ -131,7 +131,7 @@ func TestActionValidation(t *testing.T) {
 		t.Fatalf("Expect error: %s, actual err: %s", pilosa.ErrName, err)
 	}
 
-	frame = pilosa.InputFrame{Name: "f", Options: pilosa.FrameOptions{RowLabel: "row"}}
+	frame = pilosa.InputFrame{Name: "f", Options: pilosa.FrameOptions{}}
 	action = pilosa.Action{ValueDestination: pilosa.InputSingleRowBool, RowID: &rowID}
 	field = pilosa.InputDefinitionField{Name: "id", PrimaryKey: true, Actions: []pilosa.Action{action}}
 	info = pilosa.InputDefinitionInfo{Frames: []pilosa.InputFrame{frame}, Fields: []pilosa.InputDefinitionField{field}}
diff --git a/internal/private.pb.go b/internal/private.pb.go
index 1b7f71ac4..488aca0fe 100644
--- a/internal/private.pb.go
+++ b/internal/private.pb.go
@@ -92,7 +92,6 @@ func (m *IndexMeta) GetTimeQuantum() string {
 }
 
 type FrameMeta struct {
-	RowLabel       string   `protobuf:"bytes,1,opt,name=RowLabel,proto3" json:"RowLabel,omitempty"`
 	InverseEnabled bool     `protobuf:"varint,2,opt,name=InverseEnabled,proto3" json:"InverseEnabled,omitempty"`
 	CacheType      string   `protobuf:"bytes,3,opt,name=CacheType,proto3" json:"CacheType,omitempty"`
 	CacheSize      uint32   `protobuf:"varint,4,opt,name=CacheSize,proto3" json:"CacheSize,omitempty"`
@@ -106,13 +105,6 @@ func (m *FrameMeta) String() string            { return proto.CompactTextString(
 func (*FrameMeta) ProtoMessage()               {}
 func (*FrameMeta) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{1} }
 
-func (m *FrameMeta) GetRowLabel() string {
-	if m != nil {
-		return m.RowLabel
-	}
-	return ""
-}
-
 func (m *FrameMeta) GetInverseEnabled() bool {
 	if m != nil {
 		return m.InverseEnabled
@@ -1278,12 +1270,6 @@ func (m *FrameMeta) MarshalTo(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if len(m.RowLabel) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.RowLabel)))
-		i += copy(dAtA[i:], m.RowLabel)
-	}
 	if m.InverseEnabled {
 		dAtA[i] = 0x10
 		i++
@@ -2788,10 +2774,6 @@ func (m *IndexMeta) Size() (n int) {
 func (m *FrameMeta) Size() (n int) {
 	var l int
 	_ = l
-	l = len(m.RowLabel)
-	if l > 0 {
-		n += 1 + l + sovPrivate(uint64(l))
-	}
 	if m.InverseEnabled {
 		n += 2
 	}
@@ -3583,35 +3565,6 @@ func (m *FrameMeta) Unmarshal(dAtA []byte) error {
 			return fmt.Errorf("proto: FrameMeta: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RowLabel", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowPrivate
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthPrivate
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.RowLabel = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
 		case 2:
 			if wireType != 0 {
 				return fmt.Errorf("proto: wrong wireType = %d for field InverseEnabled", wireType)
@@ -8667,89 +8620,88 @@ var (
 func init() { proto.RegisterFile("private.proto", fileDescriptorPrivate) }
 
 var fileDescriptorPrivate = []byte{
-	// 1334 bytes of a gzipped FileDescriptorProto
+	// 1326 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0x5d, 0x6f, 0x1b, 0x45,
-	0x17, 0x7e, 0xd7, 0x6b, 0x3b, 0xf6, 0x71, 0x9c, 0x38, 0xd3, 0x34, 0xaf, 0x13, 0x45, 0xae, 0x19,
-	0x15, 0x1a, 0x2a, 0x11, 0x95, 0x54, 0x42, 0x34, 0x50, 0xa9, 0xc4, 0x76, 0xd5, 0x85, 0x26, 0x94,
-	0x71, 0x12, 0x24, 0x24, 0x90, 0x26, 0xf6, 0x90, 0xae, 0xb2, 0xde, 0x35, 0xbb, 0xe3, 0x24, 0xee,
-	0x05, 0x97, 0x08, 0x09, 0x71, 0x8f, 0xb8, 0xe5, 0xcf, 0x70, 0xc9, 0x4f, 0x40, 0xe1, 0x47, 0x20,
-	0x71, 0x03, 0x9a, 0xaf, 0xdd, 0xf5, 0x57, 0xd2, 0x04, 0xee, 0xf6, 0x3c, 0x73, 0xce, 0x99, 0x67,
-	0xce, 0xd7, 0xcc, 0x42, 0xb9, 0x1f, 0xba, 0xa7, 0x94, 0xb3, 0xcd, 0x7e, 0x18, 0xf0, 0x00, 0x15,
-	0x5c, 0x9f, 0xb3, 0xd0, 0xa7, 0x1e, 0xfe, 0x14, 0x8a, 0x8e, 0xdf, 0x65, 0xe7, 0xbb, 0x8c, 0x53,
-	0x54, 0x87, 0x52, 0x23, 0xf0, 0x06, 0x3d, 0xff, 0x39, 0x3d, 0x62, 0x5e, 0xd5, 0xaa, 0x5b, 0x1b,
-	0x45, 0x92, 0x86, 0x84, 0xc6, 0xbe, 0xdb, 0x63, 0x9f, 0x0d, 0xa8, 0xcf, 0x07, 0xbd, 0x6a, 0x46,
-	0x69, 0xa4, 0x20, 0xfc, 0x97, 0x05, 0xc5, 0xa7, 0x21, 0xed, 0x31, 0xe9, 0x71, 0x0d, 0x0a, 0x24,
-	0x38, 0x4b, 0xbb, 0x8b, 0x65, 0xf4, 0x16, 0x2c, 0x38, 0xfe, 0x29, 0x0b, 0x23, 0xd6, 0xf2, 0xe9,
-	0x91, 0xc7, 0xba, 0xd2, 0x5d, 0x81, 0x8c, 0xa1, 0x68, 0x1d, 0x8a, 0x0d, 0xda, 0x79, 0xc9, 0xf6,
-	0x87, 0x7d, 0x56, 0xb5, 0xa5, 0x93, 0x04, 0x88, 0x57, 0xdb, 0xee, 0x2b, 0x56, 0xcd, 0xd6, 0xad,
-	0x8d, 0x32, 0x49, 0x80, 0x71, 0xbe, 0xb9, 0x09, 0xbe, 0x08, 0xc3, 0x3c, 0xa1, 0xfe, 0x71, 0xcc,
-	0x21, 0x2f, 0x39, 0x8c, 0x60, 0xe8, 0x1e, 0xe4, 0x9f, 0xba, 0xcc, 0xeb, 0x46, 0xd5, 0xb9, 0xba,
-	0xbd, 0x51, 0xda, 0x5a, 0xdc, 0x34, 0xf1, 0xdb, 0x94, 0x38, 0xd1, 0xcb, 0x18, 0xc3, 0x82, 0xd3,
-	0xeb, 0x07, 0x21, 0x27, 0x2c, 0xea, 0x07, 0x7e, 0xc4, 0x50, 0x05, 0xec, 0x56, 0x18, 0xea, 0xb3,
-	0x8b, 0x4f, 0xfc, 0x2d, 0x54, 0x76, 0xbc, 0xa0, 0x73, 0xd2, 0xa4, 0x9c, 0x12, 0xf6, 0xcd, 0x80,
-	0x45, 0x1c, 0x2d, 0x43, 0x4e, 0x66, 0x41, 0xeb, 0x29, 0x41, 0xa0, 0x32, 0x92, 0x3a, 0xcc, 0x4a,
-	0x10, 0xa8, 0xb4, 0x97, 0xa1, 0xc8, 0x12, 0x25, 0x08, 0xb4, 0xed, 0xb9, 0x1d, 0x15, 0x82, 0x2c,
-	0x51, 0x02, 0x42, 0x90, 0x3d, 0x74, 0xd9, 0x99, 0x3e, 0xb7, 0xfc, 0xc6, 0x0e, 0x2c, 0xa5, 0xf6,
-	0xd7, 0x34, 0x57, 0x20, 0x4f, 0x82, 0x33, 0xa7, 0x19, 0x55, 0xad, 0xba, 0xbd, 0x91, 0x25, 0x5a,
-	0x92, 0xd1, 0x95, 0xe9, 0x17, 0x4b, 0x19, 0xb9, 0x94, 0x00, 0x78, 0x15, 0x72, 0x32, 0xd4, 0xe2,
-	0x94, 0x89, 0xad, 0xf8, 0xc4, 0x7f, 0x5b, 0x50, 0xdc, 0xa5, 0xe7, 0x92, 0x46, 0x84, 0x1e, 0x43,
-	0xa1, 0xcd, 0xa9, 0xdf, 0xa5, 0x61, 0x57, 0x2a, 0x95, 0xb6, 0xde, 0x48, 0x42, 0x18, 0xab, 0x6d,
-	0x1a, 0x9d, 0x96, 0xcf, 0xc3, 0x21, 0x89, 0x4d, 0xd0, 0x36, 0xcc, 0xe9, 0x9a, 0x90, 0x1c, 0x4a,
-	0x5b, 0xf5, 0x69, 0xd6, 0x71, 0xd9, 0x08, 0x63, 0x63, 0xb0, 0xf6, 0x01, 0x94, 0x47, 0xdc, 0x0a,
-	0xae, 0x27, 0x6c, 0x68, 0x32, 0x72, 0xc2, 0x86, 0x22, 0x76, 0xa7, 0xd4, 0x1b, 0xa8, 0x38, 0x67,
-	0x89, 0x12, 0xb6, 0x33, 0xef, 0x5b, 0x6b, 0xdb, 0x30, 0x9f, 0xf6, 0x7a, 0x1d, 0x5b, 0xfc, 0x15,
-	0xa0, 0x46, 0xc8, 0x28, 0x67, 0x92, 0xde, 0x2e, 0x8b, 0x22, 0x7a, 0xcc, 0x66, 0x67, 0x5a, 0x65,
-	0x2f, 0x93, 0xce, 0xde, 0x3a, 0x14, 0x9d, 0xc8, 0x1c, 0xdc, 0x96, 0x75, 0x99, 0x00, 0xf8, 0x3e,
-	0xa0, 0x26, 0xf3, 0x18, 0x67, 0xba, 0x7f, 0x2f, 0xf1, 0x8f, 0xdb, 0x86, 0xcb, 0xd5, 0xba, 0xe8,
-	0x1e, 0x64, 0x45, 0xeb, 0x4a, 0x2a, 0xa5, 0xad, 0x5b, 0x49, 0xa4, 0xe3, 0x39, 0x41, 0xa4, 0x02,
-	0x76, 0x8d, 0x53, 0xdd, 0xee, 0x57, 0x1c, 0x70, 0x4a, 0x29, 0x9b, 0xad, 0xec, 0xf1, 0xad, 0xe2,
-	0x01, 0xa2, 0xb7, 0x7a, 0x62, 0xce, 0x7a, 0xd3, 0xad, 0xf0, 0x71, 0x4c, 0x56, 0x74, 0xea, 0x4d,
-	0xc8, 0xbe, 0x09, 0x39, 0x69, 0xab, 0xd9, 0x4e, 0xcc, 0x00, 0xb5, 0x8a, 0x0f, 0x63, 0xaa, 0x37,
-	0xdd, 0x68, 0x39, 0xbd, 0x51, 0xd1, 0xf8, 0xfd, 0x42, 0xeb, 0x8a, 0x9e, 0xde, 0x13, 0x36, 0xca,
-	0x93, 0xfc, 0x9e, 0x9d, 0xb3, 0xb1, 0x40, 0x0a, 0xdf, 0x62, 0x08, 0x44, 0x55, 0xbb, 0x6e, 0x0b,
-	0xdf, 0x52, 0xc0, 0x0f, 0x21, 0xdf, 0xee, 0xbc, 0x64, 0x3d, 0x8a, 0xde, 0x16, 0x9d, 0xd6, 0x65,
-	0xe7, 0x2c, 0xd2, 0x7d, 0xba, 0x38, 0x96, 0x7f, 0x62, 0xd6, 0xf1, 0x0f, 0x96, 0x3e, 0xd3, 0x0c,
-	0x46, 0x79, 0xb9, 0x77, 0x54, 0xcd, 0x4e, 0x8c, 0x4c, 0x81, 0x13, 0xbd, 0x8c, 0x5a, 0x50, 0x71,
-	0xfc, 0xfe, 0x80, 0x37, 0xd9, 0xd7, 0xae, 0xef, 0x72, 0x37, 0xf0, 0xa3, 0x6a, 0x5e, 0x9a, 0xac,
-	0xa6, 0xb7, 0x1e, 0xd1, 0x20, 0x13, 0x26, 0xf8, 0x3b, 0x0b, 0x16, 0xc7, 0xc0, 0x2b, 0x78, 0x65,
-	0x2e, 0xe7, 0xf5, 0x5e, 0x3c, 0xf3, 0x6d, 0xa9, 0x58, 0x9b, 0xc9, 0x66, 0xf4, 0x0a, 0xf8, 0xc5,
-	0x82, 0xe5, 0x69, 0x0a, 0x53, 0xd9, 0xd4, 0x00, 0x5e, 0x84, 0x6e, 0x8f, 0x86, 0xc3, 0x4f, 0xd8,
-	0x50, 0x5f, 0x7f, 0x29, 0x04, 0x7d, 0x0e, 0x2b, 0x63, 0xbe, 0x3e, 0xea, 0xa8, 0x10, 0x29, 0x52,
-	0x77, 0x66, 0x92, 0x52, 0x7a, 0x64, 0x86, 0x39, 0xfe, 0xd3, 0x82, 0xdb, 0x53, 0x97, 0x92, 0x9a,
-	0xb4, 0xd2, 0x35, 0x79, 0x1f, 0x2a, 0x87, 0x62, 0xb2, 0x35, 0x59, 0xc4, 0x5d, 0x9f, 0x0a, 0x4d,
-	0x5d, 0xb4, 0x13, 0x38, 0x72, 0xa0, 0x20, 0xb1, 0x5d, 0xda, 0xd7, 0x34, 0xdf, 0xb9, 0x82, 0xe6,
-	0xa6, 0xd1, 0xd7, 0x83, 0xdf, 0x88, 0x82, 0x8c, 0xbc, 0x88, 0xcc, 0xad, 0x26, 0x05, 0x31, 0xd2,
-	0x47, 0x0c, 0xae, 0x35, 0x96, 0x03, 0x58, 0x37, 0xa3, 0x70, 0x84, 0xc9, 0xe5, 0x9d, 0xfa, 0x08,
-	0x20, 0x51, 0xd5, 0x13, 0xe0, 0x92, 0xfa, 0x4c, 0x29, 0xe3, 0x67, 0xb0, 0x6e, 0xe6, 0xf4, 0x35,
-	0x36, 0x34, 0xd5, 0x92, 0x49, 0xaa, 0x05, 0xb7, 0xc0, 0x3e, 0x20, 0x8e, 0xb8, 0xab, 0x65, 0xb7,
-	0x9a, 0x14, 0x69, 0x49, 0x98, 0x3c, 0x0b, 0x22, 0x6e, 0x4c, 0xc4, 0xb7, 0xc0, 0x5e, 0x04, 0x21,
-	0x97, 0x8c, 0xcb, 0x44, 0x7e, 0xe3, 0x2f, 0x21, 0xbb, 0x17, 0x74, 0x19, 0x5a, 0x80, 0x8c, 0xd3,
-	0xd4, 0x3e, 0x32, 0x4e, 0x13, 0xdd, 0x91, 0xee, 0xf5, 0x0c, 0x29, 0x27, 0x87, 0x3b, 0x20, 0x0e,
-	0x91, 0x1b, 0xdf, 0x85, 0xb2, 0x13, 0x35, 0x82, 0x20, 0xec, 0x8a, 0x54, 0x07, 0xa1, 0xbe, 0x93,
-	0x46, 0x41, 0xfc, 0x04, 0x2a, 0xc2, 0x7d, 0x9b, 0x53, 0x1e, 0x4f, 0xea, 0x15, 0xc8, 0x0b, 0x2c,
-	0xde, 0x4e, 0x4b, 0xf2, 0xde, 0x13, 0x7a, 0x66, 0x00, 0x4a, 0x01, 0x3f, 0x57, 0x1e, 0x5a, 0xa7,
-	0xcc, 0xe7, 0xa9, 0x28, 0x49, 0x59, 0x3a, 0x28, 0x13, 0x25, 0x20, 0xac, 0x8e, 0xa2, 0x39, 0x2f,
-	0x24, 0x9c, 0x05, 0x4a, 0xe4, 0x1a, 0xfe, 0xd1, 0x02, 0x30, 0x84, 0x06, 0x51, 0x6c, 0x62, 0xcd,
-	0x36, 0x41, 0xef, 0xa6, 0xde, 0x2e, 0x93, 0x33, 0x35, 0x5e, 0x22, 0xa9, 0x17, 0xce, 0x86, 0x19,
-	0xa1, 0xba, 0x38, 0x2a, 0x89, 0xbe, 0xc2, 0x75, 0x9a, 0xc4, 0xb5, 0x59, 0x6e, 0x78, 0x83, 0x88,
-	0xb3, 0x50, 0x33, 0x12, 0x6f, 0x2c, 0x05, 0xc4, 0xf1, 0x49, 0x80, 0xe9, 0x21, 0x42, 0x77, 0x21,
-	0x27, 0x98, 0x9a, 0x39, 0x30, 0x7e, 0x0c, 0xb5, 0x88, 0xdb, 0xfa, 0x26, 0x99, 0x3a, 0x7b, 0x10,
-	0x64, 0xe5, 0x8b, 0x5a, 0x97, 0x8b, 0x7c, 0x4c, 0x57, 0xc0, 0xde, 0x75, 0x55, 0x7d, 0xdb, 0x44,
-	0x7c, 0x4a, 0x84, 0x9e, 0xcb, 0xfe, 0x13, 0x08, 0x15, 0x6f, 0x89, 0x25, 0xd5, 0x40, 0xe2, 0xee,
-	0xb8, 0xc9, 0xfd, 0x66, 0x1e, 0xa5, 0x76, 0xea, 0x51, 0xda, 0x86, 0x25, 0xd5, 0x24, 0xff, 0xa5,
-	0xd3, 0x9f, 0x33, 0xb0, 0x44, 0x58, 0xe4, 0xbe, 0x62, 0x8e, 0x1f, 0xf1, 0x70, 0x10, 0x0f, 0xb8,
-	0x8f, 0x83, 0x23, 0x1d, 0x6a, 0x9b, 0x28, 0xe1, 0x75, 0x2a, 0x09, 0x3d, 0x10, 0xbf, 0x47, 0xa3,
-	0xd5, 0x3f, 0xa9, 0x9a, 0x56, 0x41, 0x0f, 0x60, 0xae, 0x1d, 0x0c, 0xc2, 0x4e, 0x7c, 0x0d, 0xae,
-	0x24, 0xda, 0x8a, 0x99, 0x5a, 0x26, 0x46, 0x2d, 0x55, 0x47, 0xb9, 0xcb, 0xeb, 0x08, 0x3d, 0x1e,
-	0xab, 0x23, 0xf9, 0xe7, 0x52, 0xda, 0xfa, 0x7f, 0x62, 0x30, 0xb2, 0x4c, 0x46, 0xb5, 0xf1, 0xf7,
-	0x16, 0xcc, 0xa7, 0x29, 0xbc, 0x56, 0x63, 0xc4, 0x19, 0xc9, 0x4c, 0xcd, 0x88, 0x3d, 0x2d, 0x23,
-	0xd9, 0x24, 0x23, 0xc9, 0x3b, 0x37, 0x97, 0x7a, 0xe7, 0xe2, 0x13, 0x58, 0x9d, 0x48, 0x53, 0x23,
-	0xe8, 0xf5, 0x45, 0x3d, 0xfc, 0x8b, 0x74, 0x89, 0x91, 0x11, 0x86, 0x3a, 0x51, 0x45, 0xa2, 0x04,
-	0xfc, 0x08, 0x6e, 0xb7, 0x19, 0x4f, 0x25, 0xc9, 0x54, 0x5b, 0x1d, 0xec, 0x3d, 0x76, 0x36, 0xe3,
-	0xf8, 0x62, 0x09, 0x7f, 0x08, 0xd5, 0x83, 0x7e, 0x97, 0x72, 0x76, 0x23, 0xeb, 0x1d, 0x28, 0xec,
-	0x07, 0xfd, 0xc0, 0x0b, 0x8e, 0x87, 0x57, 0xb4, 0x7c, 0x15, 0xe6, 0xd4, 0x7c, 0x54, 0x8f, 0x94,
-	0x22, 0x31, 0x22, 0xbe, 0x25, 0x0a, 0xba, 0x43, 0xbd, 0xce, 0xc0, 0x13, 0x34, 0xc4, 0xbf, 0x57,
-	0xb4, 0x53, 0xf9, 0xf5, 0xa2, 0x66, 0xfd, 0x76, 0x51, 0xb3, 0x7e, 0xbf, 0xa8, 0x59, 0x3f, 0xfd,
-	0x51, 0xfb, 0xdf, 0x51, 0x5e, 0xfe, 0xe5, 0x3f, 0xfc, 0x27, 0x00, 0x00, 0xff, 0xff, 0x66, 0x19,
-	0x3d, 0xd2, 0xf6, 0x0f, 0x00, 0x00,
+	0x17, 0x7e, 0xd7, 0x6b, 0x3b, 0xf1, 0x71, 0x9d, 0x3a, 0xd3, 0x36, 0xaf, 0x5b, 0x45, 0xae, 0x19,
+	0x15, 0x1a, 0x2a, 0x11, 0x95, 0x54, 0x42, 0xb4, 0x50, 0xa9, 0xd4, 0x76, 0xd5, 0x85, 0xa6, 0x94,
+	0x71, 0x5b, 0x24, 0x24, 0x90, 0x26, 0xf6, 0x90, 0xae, 0xb2, 0xde, 0x35, 0xbb, 0xe3, 0x34, 0xee,
+	0x05, 0x97, 0x08, 0x09, 0x71, 0x8f, 0xb8, 0xe5, 0xcf, 0x70, 0xc9, 0x2f, 0x40, 0xa8, 0xfc, 0x08,
+	0x2e, 0x41, 0x67, 0x3e, 0x76, 0xd7, 0x5f, 0x49, 0x1b, 0xb8, 0xdb, 0xf3, 0xcc, 0x39, 0x67, 0x9e,
+	0x39, 0x5f, 0x33, 0x0b, 0xb5, 0x51, 0xec, 0x1f, 0x72, 0x29, 0xb6, 0x47, 0x71, 0x24, 0x23, 0xb2,
+	0xea, 0x87, 0x52, 0xc4, 0x21, 0x0f, 0xe8, 0xa7, 0x50, 0xf1, 0xc2, 0x81, 0x38, 0xda, 0x15, 0x92,
+	0x93, 0x16, 0x54, 0xdb, 0x51, 0x30, 0x1e, 0x86, 0x0f, 0xf8, 0x9e, 0x08, 0x1a, 0x4e, 0xcb, 0xd9,
+	0xaa, 0xb0, 0x3c, 0x84, 0x1a, 0x8f, 0xfd, 0xa1, 0xf8, 0x6c, 0xcc, 0x43, 0x39, 0x1e, 0x36, 0x0a,
+	0x5a, 0x23, 0x07, 0xd1, 0xdf, 0x1d, 0xa8, 0xdc, 0x8b, 0xf9, 0x50, 0x28, 0x8f, 0x6f, 0xc1, 0x9a,
+	0x17, 0x1e, 0x8a, 0x38, 0x11, 0xdd, 0x90, 0xef, 0x05, 0x62, 0xa0, 0x4c, 0x56, 0xd9, 0x0c, 0x4a,
+	0x36, 0xa1, 0xd2, 0xe6, 0xfd, 0x67, 0xe2, 0xf1, 0x64, 0x24, 0x1a, 0xae, 0xf2, 0x9a, 0x01, 0xe9,
+	0x6a, 0xcf, 0x7f, 0x21, 0x1a, 0xc5, 0x96, 0xb3, 0x55, 0x63, 0x19, 0x30, 0xcb, 0xa9, 0x34, 0xc7,
+	0x89, 0x50, 0x38, 0xc3, 0x78, 0xb8, 0x9f, 0x72, 0x28, 0x2b, 0x0e, 0x53, 0x18, 0xb9, 0x0a, 0xe5,
+	0x7b, 0xbe, 0x08, 0x06, 0x49, 0x63, 0xa5, 0xe5, 0x6e, 0x55, 0x77, 0xce, 0x6e, 0xdb, 0x18, 0x6d,
+	0x2b, 0x9c, 0x99, 0x65, 0x4a, 0x61, 0xcd, 0x1b, 0x8e, 0xa2, 0x58, 0x32, 0x91, 0x8c, 0xa2, 0x30,
+	0x11, 0xa4, 0x0e, 0x6e, 0x37, 0x8e, 0x4d, 0xb8, 0xf0, 0x93, 0x7e, 0x0b, 0xf5, 0xbb, 0x41, 0xd4,
+	0x3f, 0xe8, 0x70, 0xc9, 0x99, 0xf8, 0x66, 0x2c, 0x12, 0x49, 0xce, 0x43, 0x49, 0x45, 0xda, 0xe8,
+	0x69, 0x01, 0x51, 0x15, 0x2d, 0x13, 0x4a, 0x2d, 0x20, 0xaa, 0xec, 0x55, 0x28, 0x8a, 0x4c, 0x0b,
+	0x88, 0xf6, 0x02, 0xbf, 0xaf, 0x43, 0x50, 0x64, 0x5a, 0x20, 0x04, 0x8a, 0x4f, 0x7d, 0xf1, 0xdc,
+	0x9c, 0x5b, 0x7d, 0x53, 0x0f, 0xd6, 0x73, 0xfb, 0x1b, 0x9a, 0x1b, 0x50, 0x66, 0xd1, 0x73, 0xaf,
+	0x93, 0x34, 0x9c, 0x96, 0xbb, 0x55, 0x64, 0x46, 0x52, 0xd1, 0x55, 0x29, 0xc6, 0xa5, 0x82, 0x5a,
+	0xca, 0x00, 0x7a, 0x11, 0x4a, 0x2a, 0xd4, 0x78, 0xca, 0xcc, 0x16, 0x3f, 0xe9, 0xdf, 0x0e, 0x54,
+	0x76, 0xf9, 0x91, 0xa2, 0x91, 0x90, 0xdb, 0xb0, 0xda, 0x93, 0x3c, 0x1c, 0xf0, 0x78, 0xa0, 0x94,
+	0xaa, 0x3b, 0x6f, 0x64, 0x21, 0x4c, 0xd5, 0xb6, 0xad, 0x4e, 0x37, 0x94, 0xf1, 0x84, 0xa5, 0x26,
+	0xe4, 0x16, 0xac, 0x98, 0x9a, 0x50, 0x1c, 0xaa, 0x3b, 0xad, 0x45, 0xd6, 0x69, 0xd9, 0xa0, 0xb1,
+	0x35, 0xb8, 0xf4, 0x01, 0xd4, 0xa6, 0xdc, 0x22, 0xd7, 0x03, 0x31, 0xb1, 0x19, 0x39, 0x10, 0x13,
+	0x8c, 0xdd, 0x21, 0x0f, 0xc6, 0x3a, 0xce, 0x45, 0xa6, 0x85, 0x5b, 0x85, 0xf7, 0x9d, 0x4b, 0xb7,
+	0xe0, 0x4c, 0xde, 0xeb, 0xeb, 0xd8, 0xd2, 0xaf, 0x80, 0xb4, 0x63, 0xc1, 0xa5, 0x50, 0xf4, 0x76,
+	0x45, 0x92, 0xf0, 0x7d, 0xb1, 0x3c, 0xd3, 0x3a, 0x7b, 0x85, 0x7c, 0xf6, 0x36, 0xa1, 0xe2, 0x25,
+	0xf6, 0xe0, 0xae, 0xaa, 0xcb, 0x0c, 0xa0, 0xd7, 0x80, 0x74, 0x44, 0x20, 0xa4, 0x30, 0x3d, 0x7a,
+	0x8c, 0x7f, 0xda, 0xb3, 0x5c, 0x4e, 0xd6, 0x25, 0x57, 0xa1, 0x88, 0xed, 0xa9, 0xa8, 0x54, 0x77,
+	0xce, 0x65, 0x91, 0x4e, 0x67, 0x01, 0x53, 0x0a, 0xd4, 0xb7, 0x4e, 0x4d, 0x4b, 0x9f, 0x70, 0xc0,
+	0x05, 0xa5, 0x6c, 0xb7, 0x72, 0x67, 0xb7, 0x4a, 0x87, 0x84, 0xd9, 0xea, 0x8e, 0x3d, 0xeb, 0x69,
+	0xb7, 0xa2, 0xfb, 0x29, 0x59, 0xec, 0xd4, 0xd3, 0x90, 0x7d, 0x13, 0x4a, 0xca, 0xd6, 0xb0, 0x9d,
+	0x9b, 0x01, 0x7a, 0x95, 0x3e, 0x4d, 0xa9, 0x9e, 0x76, 0xa3, 0xf3, 0xf9, 0x8d, 0x2a, 0xd6, 0xef,
+	0x17, 0x46, 0x17, 0x7b, 0xfa, 0x21, 0xda, 0x68, 0x4f, 0xea, 0x7b, 0x79, 0xce, 0x66, 0x02, 0x89,
+	0xbe, 0x71, 0x08, 0x24, 0x0d, 0xb7, 0xe5, 0xa2, 0x6f, 0x25, 0xd0, 0x1b, 0x50, 0xee, 0xf5, 0x9f,
+	0x89, 0x21, 0x27, 0x6f, 0x63, 0xa7, 0x0d, 0xc4, 0x91, 0x48, 0x4c, 0x9f, 0x9e, 0x9d, 0xc9, 0x3f,
+	0xb3, 0xeb, 0xf4, 0x07, 0xc7, 0x9c, 0x69, 0x09, 0xa3, 0xb2, 0xda, 0x3b, 0x69, 0x14, 0xe7, 0x46,
+	0x26, 0xe2, 0xcc, 0x2c, 0x93, 0x2e, 0xd4, 0xbd, 0x70, 0x34, 0x96, 0x1d, 0xf1, 0xb5, 0x1f, 0xfa,
+	0xd2, 0x8f, 0xc2, 0xa4, 0x51, 0x56, 0x26, 0x17, 0xf3, 0x5b, 0x4f, 0x69, 0xb0, 0x39, 0x13, 0xfa,
+	0x9d, 0x03, 0x67, 0x67, 0xc0, 0x13, 0x78, 0x15, 0x8e, 0xe7, 0xf5, 0x5e, 0x3a, 0xf3, 0x5d, 0xa5,
+	0xd8, 0x5c, 0xca, 0x66, 0xfa, 0x0a, 0xf8, 0xc5, 0x81, 0xf3, 0x8b, 0x14, 0x16, 0xb2, 0x69, 0x02,
+	0x3c, 0x8a, 0xfd, 0x21, 0x8f, 0x27, 0x9f, 0x88, 0x89, 0xb9, 0xfe, 0x72, 0x08, 0xf9, 0x1c, 0x36,
+	0x66, 0x7c, 0x7d, 0xd4, 0xd7, 0x21, 0xd2, 0xa4, 0x2e, 0x2f, 0x25, 0xa5, 0xf5, 0xd8, 0x12, 0x73,
+	0xfa, 0x97, 0x03, 0x17, 0x16, 0x2e, 0x65, 0x35, 0xe9, 0xe4, 0x6b, 0xf2, 0x1a, 0xd4, 0x9f, 0xe2,
+	0x64, 0xeb, 0x88, 0x44, 0xfa, 0x21, 0x47, 0x4d, 0x53, 0xb4, 0x73, 0x38, 0xf1, 0x60, 0x55, 0x61,
+	0xbb, 0x7c, 0x64, 0x68, 0xbe, 0x73, 0x02, 0xcd, 0x6d, 0xab, 0x6f, 0x06, 0xbf, 0x15, 0x91, 0x8c,
+	0xba, 0x88, 0xec, 0xad, 0xa6, 0x04, 0x1c, 0xe9, 0x53, 0x06, 0xaf, 0x35, 0x96, 0x23, 0xd8, 0xb4,
+	0xa3, 0x70, 0x8a, 0xc9, 0xf1, 0x9d, 0x7a, 0x13, 0x20, 0x53, 0x35, 0x13, 0xe0, 0x98, 0xfa, 0xcc,
+	0x29, 0xd3, 0xfb, 0xb0, 0x69, 0xe7, 0xf4, 0x6b, 0x6c, 0x68, 0xab, 0xa5, 0x90, 0x55, 0x0b, 0xed,
+	0x82, 0xfb, 0x84, 0x79, 0x78, 0x57, 0xab, 0x6e, 0xb5, 0x29, 0x32, 0x12, 0x9a, 0xdc, 0x8f, 0x12,
+	0x69, 0x4d, 0xf0, 0x1b, 0xb1, 0x47, 0x51, 0x2c, 0x15, 0xe3, 0x1a, 0x53, 0xdf, 0xf4, 0x4b, 0x28,
+	0x3e, 0x8c, 0x06, 0x82, 0xac, 0x41, 0xc1, 0xeb, 0x18, 0x1f, 0x05, 0xaf, 0x43, 0x2e, 0x2b, 0xf7,
+	0x66, 0x86, 0xd4, 0xb2, 0xc3, 0x3d, 0x61, 0x1e, 0x53, 0x1b, 0x5f, 0x81, 0x9a, 0x97, 0xb4, 0xa3,
+	0x28, 0x1e, 0x60, 0xaa, 0xa3, 0xd8, 0xdc, 0x49, 0xd3, 0x20, 0xbd, 0x03, 0x75, 0x74, 0xdf, 0x93,
+	0x5c, 0xa6, 0x93, 0x7a, 0x03, 0xca, 0x88, 0xa5, 0xdb, 0x19, 0x49, 0xdd, 0x7b, 0xa8, 0x67, 0x07,
+	0xa0, 0x12, 0xe8, 0x03, 0xed, 0xa1, 0x7b, 0x28, 0x42, 0x99, 0x8b, 0x92, 0x92, 0x95, 0x83, 0x1a,
+	0xd3, 0x02, 0xa1, 0xfa, 0x28, 0x86, 0xf3, 0x5a, 0xc6, 0x19, 0x51, 0xa6, 0xd6, 0xe8, 0x8f, 0x0e,
+	0x80, 0x25, 0x34, 0x4e, 0x52, 0x13, 0x67, 0xb9, 0x09, 0x79, 0x37, 0xf7, 0x76, 0x99, 0x9f, 0xa9,
+	0xe9, 0x12, 0xcb, 0xbd, 0x70, 0xb6, 0xec, 0x08, 0x35, 0xc5, 0x51, 0xcf, 0xf4, 0x35, 0x6e, 0xd2,
+	0x84, 0xd7, 0x66, 0xad, 0x1d, 0x8c, 0x13, 0x29, 0x62, 0xc3, 0x08, 0xdf, 0x58, 0x1a, 0x48, 0xe3,
+	0x93, 0x01, 0x8b, 0x43, 0x44, 0xae, 0x40, 0x09, 0x99, 0xda, 0x39, 0x30, 0x7b, 0x0c, 0xbd, 0x48,
+	0x7b, 0xe6, 0x26, 0x59, 0x38, 0x7b, 0x08, 0x14, 0xd5, 0x8b, 0xda, 0x94, 0x8b, 0x7a, 0x4c, 0xd7,
+	0xc1, 0xdd, 0xf5, 0x75, 0x7d, 0xbb, 0x0c, 0x3f, 0x15, 0xc2, 0x8f, 0x54, 0xff, 0x21, 0xc2, 0xf1,
+	0x2d, 0xb1, 0xae, 0x1b, 0x08, 0xef, 0x8e, 0xd3, 0xdc, 0x6f, 0xf6, 0x51, 0xea, 0xe6, 0x1e, 0xa5,
+	0x3d, 0x58, 0xd7, 0x4d, 0xf2, 0x5f, 0x3a, 0xfd, 0xb9, 0x00, 0xeb, 0x4c, 0x24, 0xfe, 0x0b, 0xe1,
+	0x85, 0x89, 0x8c, 0xc7, 0xe9, 0x80, 0xfb, 0x38, 0xda, 0x33, 0xa1, 0x76, 0x99, 0x16, 0x5e, 0xa5,
+	0x92, 0xc8, 0x75, 0xfc, 0x05, 0x9a, 0xae, 0xfe, 0x79, 0xd5, 0xbc, 0x0a, 0xb9, 0x0e, 0x2b, 0xbd,
+	0x68, 0x1c, 0xf7, 0xd3, 0x6b, 0x70, 0x23, 0xd3, 0xd6, 0xcc, 0xf4, 0x32, 0xb3, 0x6a, 0xb9, 0x3a,
+	0x2a, 0x1d, 0x5f, 0x47, 0xe4, 0xf6, 0x4c, 0x1d, 0xa9, 0x3f, 0x97, 0xea, 0xce, 0xff, 0x33, 0x83,
+	0xa9, 0x65, 0x36, 0xad, 0x4d, 0xbf, 0x77, 0xe0, 0x4c, 0x9e, 0xc2, 0x2b, 0x35, 0x46, 0x9a, 0x91,
+	0xc2, 0xc2, 0x8c, 0xb8, 0x8b, 0x32, 0x52, 0xcc, 0x32, 0x92, 0xbd, 0x73, 0x4b, 0xb9, 0x77, 0x2e,
+	0x3d, 0x80, 0x8b, 0x73, 0x69, 0x6a, 0x47, 0xc3, 0x11, 0xd6, 0xc3, 0xbf, 0x48, 0x17, 0x8e, 0x8c,
+	0x38, 0x36, 0x89, 0xaa, 0x30, 0x2d, 0xd0, 0x9b, 0x70, 0xa1, 0x27, 0x64, 0x2e, 0x49, 0xb6, 0xda,
+	0x5a, 0xe0, 0x3e, 0x14, 0xcf, 0x97, 0x1c, 0x1f, 0x97, 0xe8, 0x87, 0xd0, 0x78, 0x32, 0x1a, 0x70,
+	0x29, 0x4e, 0x65, 0x7d, 0x17, 0x56, 0x1f, 0x47, 0xa3, 0x28, 0x88, 0xf6, 0x27, 0x27, 0xb4, 0x7c,
+	0x03, 0x56, 0xf4, 0x7c, 0xd4, 0x8f, 0x94, 0x0a, 0xb3, 0x22, 0x3d, 0x87, 0x05, 0xdd, 0xe7, 0x41,
+	0x7f, 0x1c, 0x20, 0x0d, 0xfc, 0xf7, 0x4a, 0xee, 0xd6, 0x7f, 0x7d, 0xd9, 0x74, 0x7e, 0x7b, 0xd9,
+	0x74, 0xfe, 0x78, 0xd9, 0x74, 0x7e, 0xfa, 0xb3, 0xf9, 0xbf, 0xbd, 0xb2, 0xfa, 0x93, 0xbf, 0xf1,
+	0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe2, 0x13, 0x1d, 0x50, 0xda, 0x0f, 0x00, 0x00,
 }
diff --git a/internal/private.proto b/internal/private.proto
index 8642d9a13..ca987ec51 100644
--- a/internal/private.proto
+++ b/internal/private.proto
@@ -8,7 +8,6 @@ message IndexMeta {
 }
 
 message FrameMeta {
-	string RowLabel = 1;
 	bool InverseEnabled = 2;
 	string CacheType = 3;
 	uint32 CacheSize = 4;
diff --git a/pilosa.go b/pilosa.go
index 98c67203f..71b63fcaa 100644
--- a/pilosa.go
+++ b/pilosa.go
@@ -36,7 +36,6 @@ var (
 	ErrFrameExists          = errors.New("frame already exists")
 	ErrFrameNotFound        = errors.New("frame not found")
 	ErrFrameInverseDisabled = errors.New("frame inverse disabled")
-	ErrColumnRowLabelEqual  = errors.New("column and row labels cannot be equal")
 
 	ErrInputDefinitionExists         = errors.New("input-definition already exists")
 	ErrInputDefinitionHasPrimaryKey  = errors.New("input-definition must contain one PrimaryKey")
diff --git a/server/cluster_test.go b/server/cluster_test.go
index fbb784691..de623bbd4 100644
--- a/server/cluster_test.go
+++ b/server/cluster_test.go
@@ -153,8 +153,8 @@ func TestMain_SendReceiveMessage(t *testing.T) {
 
 	// Write data on first node.
 	if _, err := m0.Query("i", "", `
-            SetBit(rowID=1, frame="f", columnID=1)
-            SetBit(rowID=1, frame="f", columnID=2400000)
+            SetBit(row=1, frame="f", columnID=1)
+            SetBit(row=1, frame="f", columnID=2400000)
         `); err != nil {
 		t.Fatal(err)
 	}
@@ -351,8 +351,8 @@ func TestClusterResize_AddNode(t *testing.T) {
 
 		// Write data on first node.
 		if _, err := m0.Query("i", "", `
-				SetBit(rowID=1, frame="f", columnID=1)
-				SetBit(rowID=1, frame="f", columnID=1300000)
+				SetBit(row=1, frame="f", columnID=1)
+				SetBit(row=1, frame="f", columnID=1300000)
 			`); err != nil {
 			t.Fatal(err)
 		}
@@ -406,8 +406,8 @@ func TestClusterResize_AddNode(t *testing.T) {
 
 		// Write data on first node. Note that no data is placed on slice 1.
 		if _, err := m0.Query("i", "", `
-				SetBit(rowID=1, frame="f", columnID=1)
-				SetBit(rowID=1, frame="f", columnID=2400000)
+				SetBit(row=1, frame="f", columnID=1)
+				SetBit(row=1, frame="f", columnID=2400000)
 			`); err != nil {
 			t.Fatal(err)
 		}
@@ -560,7 +560,7 @@ func TestClusterResize_RemoveNode(t *testing.T) {
 		// TODO: Deterministic node IDs would ensure consistent results
 		setBits := ""
 		for i := 0; i < 20; i++ {
-			setBits += fmt.Sprintf("SetBit(rowID=1, frame=\"f\", columnID=%d) ", i*pilosa.SliceWidth)
+			setBits += fmt.Sprintf("SetBit(row=1, frame=\"f\", columnID=%d) ", i*pilosa.SliceWidth)
 		}
 
 		if _, err := m0.Query("i", "", setBits); err != nil {
diff --git a/server/server_test.go b/server/server_test.go
index 3852845a6..28155bab4 100644
--- a/server/server_test.go
+++ b/server/server_test.go
@@ -56,7 +56,7 @@ func TestMain_Set_Quick(t *testing.T) {
 			if err := client.CreateFrame(context.Background(), "i", cmd.Frame, pilosa.FrameOptions{}); err != nil && err != pilosa.ErrFrameExists {
 				t.Fatal(err)
 			}
-			if _, err := m.Query("i", "", fmt.Sprintf(`SetBit(rowID=%d, frame=%q, columnID=%d)`, cmd.ID, cmd.Frame, cmd.ColumnID)); err != nil {
+			if _, err := m.Query("i", "", fmt.Sprintf(`SetBit(row=%d, frame=%q, columnID=%d)`, cmd.ID, cmd.Frame, cmd.ColumnID)); err != nil {
 				t.Fatal(err)
 			}
 		}
@@ -72,7 +72,7 @@ func TestMain_Set_Quick(t *testing.T) {
 						},
 					},
 				}) + "\n"
-				if res, err := m.Query("i", "", fmt.Sprintf(`Bitmap(rowID=%d, frame=%q)`, id, frame)); err != nil {
+				if res, err := m.Query("i", "", fmt.Sprintf(`Bitmap(row=%d, frame=%q)`, id, frame)); err != nil {
 					t.Fatal(err)
 				} else if res != exp {
 					t.Fatalf("unexpected result:\n\ngot=%s\n\nexp=%s\n\n", res, exp)
@@ -95,7 +95,7 @@ func TestMain_Set_Quick(t *testing.T) {
 						},
 					},
 				}) + "\n"
-				if res, err := m.Query("i", "", fmt.Sprintf(`Bitmap(rowID=%d, frame=%q)`, id, frame)); err != nil {
+				if res, err := m.Query("i", "", fmt.Sprintf(`Bitmap(row=%d, frame=%q)`, id, frame)); err != nil {
 					t.Fatal(err)
 				} else if res != exp {
 					t.Fatalf("unexpected result (reopen):\n\ngot=%s\n\nexp=%s\n\n", res, exp)
@@ -131,36 +131,36 @@ func TestMain_SetRowAttrs(t *testing.T) {
 	}
 
 	// Set bits on different rows in different frames.
-	if _, err := m.Query("i", "", `SetBit(rowID=1, frame="x", columnID=100)`); err != nil {
+	if _, err := m.Query("i", "", `SetBit(row=1, frame="x", columnID=100)`); err != nil {
 		t.Fatal(err)
-	} else if _, err := m.Query("i", "", `SetBit(rowID=2, frame="x", columnID=100)`); err != nil {
+	} else if _, err := m.Query("i", "", `SetBit(row=2, frame="x", columnID=100)`); err != nil {
 		t.Fatal(err)
-	} else if _, err := m.Query("i", "", `SetBit(rowID=2, frame="z", columnID=100)`); err != nil {
+	} else if _, err := m.Query("i", "", `SetBit(row=2, frame="z", columnID=100)`); err != nil {
 		t.Fatal(err)
-	} else if _, err := m.Query("i", "", `SetBit(rowID=3, frame="neg", columnID=100)`); err != nil {
+	} else if _, err := m.Query("i", "", `SetBit(row=3, frame="neg", columnID=100)`); err != nil {
 		t.Fatal(err)
 	}
 
 	// Set row attributes.
-	if _, err := m.Query("i", "", `SetRowAttrs(rowID=1, frame="x", x=100)`); err != nil {
+	if _, err := m.Query("i", "", `SetRowAttrs(row=1, frame="x", x=100)`); err != nil {
 		t.Fatal(err)
-	} else if _, err := m.Query("i", "", `SetRowAttrs(rowID=2, frame="x", x=-200)`); err != nil {
+	} else if _, err := m.Query("i", "", `SetRowAttrs(row=2, frame="x", x=-200)`); err != nil {
 		t.Fatal(err)
-	} else if _, err := m.Query("i", "", `SetRowAttrs(rowID=2, frame="z", x=300)`); err != nil {
+	} else if _, err := m.Query("i", "", `SetRowAttrs(row=2, frame="z", x=300)`); err != nil {
 		t.Fatal(err)
-	} else if _, err := m.Query("i", "", `SetRowAttrs(rowID=3, frame="neg", x=-0.44)`); err != nil {
+	} else if _, err := m.Query("i", "", `SetRowAttrs(row=3, frame="neg", x=-0.44)`); err != nil {
 		t.Fatal(err)
 	}
 
 	// Query row x/1.
-	if res, err := m.Query("i", "", `Bitmap(rowID=1, frame="x")`); err != nil {
+	if res, err := m.Query("i", "", `Bitmap(row=1, frame="x")`); err != nil {
 		t.Fatal(err)
 	} else if res != `{"results":[{"attrs":{"x":100},"bits":[100]}]}`+"\n" {
 		t.Fatalf("unexpected result: %s", res)
 	}
 
 	// Query row x/2.
-	if res, err := m.Query("i", "", `Bitmap(rowID=2, frame="x")`); err != nil {
+	if res, err := m.Query("i", "", `Bitmap(row=2, frame="x")`); err != nil {
 		t.Fatal(err)
 	} else if res != `{"results":[{"attrs":{"x":-200},"bits":[100]}]}`+"\n" {
 		t.Fatalf("unexpected result: %s", res)
@@ -171,19 +171,19 @@ func TestMain_SetRowAttrs(t *testing.T) {
 	}
 
 	// Query rows after reopening.
-	if res, err := m.Query("i", "columnAttrs=true", `Bitmap(rowID=1, frame="x")`); err != nil {
+	if res, err := m.Query("i", "columnAttrs=true", `Bitmap(row=1, frame="x")`); err != nil {
 		t.Fatal(err)
 	} else if res != `{"results":[{"attrs":{"x":100},"bits":[100]}]}`+"\n" {
 		t.Fatalf("unexpected result(reopen): %s", res)
 	}
 
-	if res, err := m.Query("i", "columnAttrs=true", `Bitmap(rowID=3, frame="neg")`); err != nil {
+	if res, err := m.Query("i", "columnAttrs=true", `Bitmap(row=3, frame="neg")`); err != nil {
 		t.Fatal(err)
 	} else if res != `{"results":[{"attrs":{"x":-0.44},"bits":[100]}]}`+"\n" {
 		t.Fatalf("unexpected result(reopen): %s", res)
 	}
 	// Query row x/2.
-	if res, err := m.Query("i", "", `Bitmap(rowID=2, frame="x")`); err != nil {
+	if res, err := m.Query("i", "", `Bitmap(row=2, frame="x")`); err != nil {
 		t.Fatal(err)
 	} else if res != `{"results":[{"attrs":{"x":-200},"bits":[100]}]}`+"\n" {
 		t.Fatalf("unexpected result: %s", res)
@@ -204,9 +204,9 @@ func TestMain_SetColumnAttrs(t *testing.T) {
 	}
 
 	// Set bits on row.
-	if _, err := m.Query("i", "", `SetBit(rowID=1, frame="x", columnID=100)`); err != nil {
+	if _, err := m.Query("i", "", `SetBit(row=1, frame="x", columnID=100)`); err != nil {
 		t.Fatal(err)
-	} else if _, err := m.Query("i", "", `SetBit(rowID=1, frame="x", columnID=101)`); err != nil {
+	} else if _, err := m.Query("i", "", `SetBit(row=1, frame="x", columnID=101)`); err != nil {
 		t.Fatal(err)
 	}
 
@@ -216,7 +216,7 @@ func TestMain_SetColumnAttrs(t *testing.T) {
 	}
 
 	// Query row.
-	if res, err := m.Query("i", "columnAttrs=true", `Bitmap(rowID=1, frame="x")`); err != nil {
+	if res, err := m.Query("i", "columnAttrs=true", `Bitmap(row=1, frame="x")`); err != nil {
 		t.Fatal(err)
 	} else if res != `{"results":[{"attrs":{},"bits":[100,101]}],"columnAttrs":[{"id":100,"attrs":{"foo":"bar"}}]}`+"\n" {
 		t.Fatalf("unexpected result: %s", res)
@@ -227,7 +227,7 @@ func TestMain_SetColumnAttrs(t *testing.T) {
 	}
 
 	// Query row after reopening.
-	if res, err := m.Query("i", "columnAttrs=true", `Bitmap(rowID=1, frame="x")`); err != nil {
+	if res, err := m.Query("i", "columnAttrs=true", `Bitmap(row=1, frame="x")`); err != nil {
 		t.Fatal(err)
 	} else if res != `{"results":[{"attrs":{},"bits":[100,101]}],"columnAttrs":[{"id":100,"attrs":{"foo":"bar"}}]}`+"\n" {
 		t.Fatalf("unexpected result(reopen): %s", res)
@@ -248,9 +248,9 @@ func TestMain_SetColumnAttrsWithColumnOption(t *testing.T) {
 	}
 
 	// Set bits on row.
-	if _, err := m.Query("i", "", `SetBit(rowID=1, frame="x", col=100)`); err != nil {
+	if _, err := m.Query("i", "", `SetBit(row=1, frame="x", col=100)`); err != nil {
 		t.Fatal(err)
-	} else if _, err := m.Query("i", "", `SetBit(rowID=1, frame="x", col=101)`); err != nil {
+	} else if _, err := m.Query("i", "", `SetBit(row=1, frame="x", col=101)`); err != nil {
 		t.Fatal(err)
 	}
 
@@ -260,7 +260,7 @@ func TestMain_SetColumnAttrsWithColumnOption(t *testing.T) {
 	}
 
 	// Query row.
-	if res, err := m.Query("i", "columnAttrs=true", `Bitmap(rowID=1, frame="x")`); err != nil {
+	if res, err := m.Query("i", "columnAttrs=true", `Bitmap(row=1, frame="x")`); err != nil {
 		t.Fatal(err)
 	} else if res != `{"results":[{"attrs":{},"bits":[100,101]}],"columnAttrs":[{"id":100,"attrs":{"foo":"bar"}}]}`+"\n" {
 		t.Fatalf("unexpected result: %s", res)
@@ -285,19 +285,19 @@ func TestMain_FrameRestore(t *testing.T) {
 
 	// Write data on first cluster.
 	if _, err := m10.Query("i", "", `
-		SetBit(rowID=1, frame="f", columnID=100)
-		SetBit(rowID=1, frame="f", columnID=1000)
-		SetBit(rowID=1, frame="f", columnID=100000)
-		SetBit(rowID=1, frame="f", columnID=200000)
-		SetBit(rowID=1, frame="f", columnID=400000)
-		SetBit(rowID=1, frame="f", columnID=600000)
-		SetBit(rowID=1, frame="f", columnID=800000)
+		SetBit(row=1, frame="f", columnID=100)
+		SetBit(row=1, frame="f", columnID=1000)
+		SetBit(row=1, frame="f", columnID=100000)
+		SetBit(row=1, frame="f", columnID=200000)
+		SetBit(row=1, frame="f", columnID=400000)
+		SetBit(row=1, frame="f", columnID=600000)
+		SetBit(row=1, frame="f", columnID=800000)
 	`); err != nil {
 		t.Fatal("setting bits:", err)
 	}
 
 	// Query row on first cluster.
-	if res, err := m10.Query("i", "", `Bitmap(rowID=1, frame="f")`); err != nil {
+	if res, err := m10.Query("i", "", `Bitmap(row=1, frame="f")`); err != nil {
 		t.Fatal("bitmap query:", err)
 	} else if res != `{"results":[{"attrs":{},"bits":[100,1000,100000,200000,400000,600000,800000]}]}`+"\n" {
 		t.Fatalf("unexpected result: %s", res)
@@ -335,7 +335,7 @@ func TestMain_FrameRestore(t *testing.T) {
 	}
 
 	// Query row on second cluster.
-	if res, err := m20.Query("i", "", `Bitmap(rowID=1, frame="f")`); err != nil {
+	if res, err := m20.Query("i", "", `Bitmap(row=1, frame="f")`); err != nil {
 		t.Fatal("another bitmap query:", err)
 	} else if res != `{"results":[{"attrs":{},"bits":[100,1000,100000,200000,400000,600000,800000]}]}`+"\n" {
 		t.Fatalf("2unexpected result: %s", res)
@@ -401,7 +401,7 @@ func TestMain_RecalculateHashes(t *testing.T) {
 	data := []string{}
 	for rowID := 1; rowID < 10; rowID++ {
 		for columnID := 1; columnID < 100; columnID++ {
-			data = append(data, fmt.Sprintf(`SetBit(rowID=%d, frame="f", columnID=%d)`, rowID, columnID))
+			data = append(data, fmt.Sprintf(`SetBit(row=%d, frame="f", columnID=%d)`, rowID, columnID))
 		}
 	}
 	if _, err := cluster[0].Query("i", "", strings.Join(data, "")); err != nil {
diff --git a/stats_test.go b/stats_test.go
index 93d7d9bb1..a03407a3d 100644
--- a/stats_test.go
+++ b/stats_test.go
@@ -143,7 +143,7 @@ func TestStatsCount_Bitmap(t *testing.T) {
 			return
 		},
 	}
-	if _, err := e.Execute(context.Background(), "d", test.MustParse(`Bitmap(frame=f, rowID=0)`), nil, nil); err != nil {
+	if _, err := e.Execute(context.Background(), "d", test.MustParse(`Bitmap(frame=f, row=0)`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
 	if !called {
@@ -174,7 +174,7 @@ func TestStatsCount_SetBitmapAttrs(t *testing.T) {
 			return
 		},
 	}
-	if _, err := e.Execute(context.Background(), "d", test.MustParse(`SetRowAttrs(rowID=10, frame=f, foo="bar")`), nil, nil); err != nil {
+	if _, err := e.Execute(context.Background(), "d", test.MustParse(`SetRowAttrs(row=10, frame=f, foo="bar")`), nil, nil); err != nil {
 		t.Fatal(err)
 	}
 	if !called {