From 1f476c9078d88dbfee32d7fff60f06f5b197dd0e Mon Sep 17 00:00:00 2001
From: Travis Turner <travis@pilosa.com>
Date: Mon, 4 Jun 2018 15:32:43 -0500
Subject: [PATCH 1/9] rename oField to bsiGroup

---
 api.go                 |  12 ++---
 frame.go               | 113 +++++++++++++++++++-------------------
 frame_internal_test.go | 120 ++++++++++++++++++++---------------------
 3 files changed, 122 insertions(+), 123 deletions(-)

diff --git a/api.go b/api.go
index c02aedbf2..9a50a3542 100644
--- a/api.go
+++ b/api.go
@@ -489,7 +489,7 @@ func (api *API) Schema(ctx context.Context) []*IndexInfo {
 }
 
 // CreateField creates a new BSI field in the given index and frame.
-func (api *API) CreateField(ctx context.Context, indexName string, frameName string, field *oField) error {
+func (api *API) CreateField(ctx context.Context, indexName string, frameName string, bsig *bsiGroup) error {
 	if err := api.validate(apiCreateField); err != nil {
 		return errors.Wrap(err, "validating api method")
 	}
@@ -500,17 +500,17 @@ func (api *API) CreateField(ctx context.Context, indexName string, frameName str
 		return ErrFrameNotFound
 	}
 
-	// Create new field.
-	if err := f.CreateField(field); err != nil {
-		return errors.Wrap(err, "creating field")
+	// Create new bsiGroup.
+	if err := f.CreateField(bsig); err != nil {
+		return errors.Wrap(err, "creating bsigroup")
 	}
 
-	// Send the create field message to all nodes.
+	// Send the create bsigroup message to all nodes.
 	err := api.Broadcaster.SendSync(
 		&internal.CreateFieldMessage{
 			Index: indexName,
 			Frame: frameName,
-			Field: encodeField(field),
+			Field: encodeField(bsig),
 		})
 	if err != nil {
 		api.Logger.Printf("problem sending CreateField message: %s", err)
diff --git a/frame.go b/frame.go
index ff20bddcc..4fa755e62 100644
--- a/frame.go
+++ b/frame.go
@@ -64,7 +64,7 @@ type Frame struct {
 	// Frame options.
 	options FrameOptions
 
-	fields []*oField
+	fields []*bsiGroup
 
 	Logger Logger
 }
@@ -325,19 +325,19 @@ func (f *Frame) applyOptions(opt FrameOptions) error {
 		f.options.Max = opt.Max
 		f.options.TimeQuantum = ""
 
-		// Create new field.
-		field := &oField{
+		// Create new bsiGroup.
+		bsig := &bsiGroup{
 			Name: f.name,
 			Type: FieldTypeInt,
 			Min:  opt.Min,
 			Max:  opt.Max,
 		}
-		// Validate field.
-		if err := ValidateField(field); err != nil {
+		// Validate bsiGroup.
+		if err := ValidateField(bsig); err != nil {
 			return err
 		}
-		if err := f.CreateField(field); err != nil {
-			return errors.Wrap(err, "creating field")
+		if err := f.CreateField(bsig); err != nil {
+			return errors.Wrap(err, "creating bsigroup")
 		}
 	case FrameTypeTime:
 		f.options.Type = opt.Type
@@ -379,7 +379,7 @@ func (f *Frame) Close() error {
 }
 
 // Field returns a field by name.
-func (f *Frame) Field(name string) *oField {
+func (f *Frame) Field(name string) *bsiGroup {
 	f.mu.RLock()
 	defer f.mu.RUnlock()
 	for _, field := range f.fields {
@@ -401,12 +401,12 @@ func (f *Frame) hasField(name string) bool {
 }
 
 // CreateField creates a new field on the frame.
-func (f *Frame) CreateField(field *oField) error {
+func (f *Frame) CreateField(bsig *bsiGroup) error {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 
-	// Append field.
-	if err := f.addField(field); err != nil {
+	// Append bsiGroup.
+	if err := f.addField(bsig); err != nil {
 		return err
 	}
 	f.saveMeta()
@@ -414,15 +414,15 @@ func (f *Frame) CreateField(field *oField) error {
 }
 
 // addField adds a single field to fields.
-func (f *Frame) addField(field *oField) error {
-	if err := ValidateField(field); err != nil {
-		return errors.Wrap(err, "validating field")
-	} else if f.hasField(field.Name) {
+func (f *Frame) addField(bsig *bsiGroup) error {
+	if err := ValidateField(bsig); err != nil {
+		return errors.Wrap(err, "validating bsigroup")
+	} else if f.hasField(bsig.Name) {
 		return ErrFieldExists
 	}
 
-	// Add field to list.
-	f.fields = append(f.fields, field)
+	// Add bsiGroup to list.
+	f.fields = append(f.fields, bsig)
 
 	// Sort fields by name.
 	sort.Slice(f.fields, func(i, j int) bool {
@@ -1084,9 +1084,8 @@ func IsValidFieldType(v string) bool {
 	}
 }
 
-// TODO: finish unexporting this. also, rename it.
-// oField represents a range field on a frame.
-type oField struct {
+// bsiGroup represents a range field on a frame.
+type bsiGroup struct {
 	Name string `json:"name,omitempty"`
 	Type string `json:"type,omitempty"`
 	Min  int64  `json:"min,omitempty"`
@@ -1094,9 +1093,9 @@ type oField struct {
 }
 
 // BitDepth returns the number of bits required to store a value between min & max.
-func (f *oField) BitDepth() uint {
+func (b *bsiGroup) BitDepth() uint {
 	for i := uint(0); i < 63; i++ {
-		if f.Max-f.Min < (1 << i) {
+		if b.Max-b.Min < (1 << i) {
 			return i
 		}
 	}
@@ -1115,80 +1114,80 @@ func (f *oField) BitDepth() uint {
 // In order to make this work, we effectively need to change the operator to LTE.
 // Executor.executeFieldRangeSlice() takes this into account and returns
 // `frag.FieldNotNull(field.BitDepth())` in such instances.
-func (f *oField) BaseValue(op pql.Token, value int64) (baseValue uint64, outOfRange bool) {
+func (b *bsiGroup) BaseValue(op pql.Token, value int64) (baseValue uint64, outOfRange bool) {
 	if op == pql.GT || op == pql.GTE {
-		if value > f.Max {
+		if value > b.Max {
 			return baseValue, true
-		} else if value > f.Min {
-			baseValue = uint64(value - f.Min)
+		} else if value > b.Min {
+			baseValue = uint64(value - b.Min)
 		}
 	} else if op == pql.LT || op == pql.LTE {
-		if value < f.Min {
+		if value < b.Min {
 			return baseValue, true
-		} else if value > f.Max {
-			baseValue = uint64(f.Max - f.Min)
+		} else if value > b.Max {
+			baseValue = uint64(b.Max - b.Min)
 		} else {
-			baseValue = uint64(value - f.Min)
+			baseValue = uint64(value - b.Min)
 		}
 	} else if op == pql.EQ || op == pql.NEQ {
-		if value < f.Min || value > f.Max {
+		if value < b.Min || value > b.Max {
 			return baseValue, true
 		}
-		baseValue = uint64(value - f.Min)
+		baseValue = uint64(value - b.Min)
 	}
 	return baseValue, false
 }
 
 // BaseValueBetween adjusts the min/max value to align with the range for Field.
-func (f *oField) BaseValueBetween(min, max int64) (baseValueMin, baseValueMax uint64, outOfRange bool) {
-	if max < f.Min || min > f.Max {
+func (b *bsiGroup) BaseValueBetween(min, max int64) (baseValueMin, baseValueMax uint64, outOfRange bool) {
+	if max < b.Min || min > b.Max {
 		return baseValueMin, baseValueMax, true
 	}
 	// Adjust min/max to range.
-	if min > f.Min {
-		baseValueMin = uint64(min - f.Min)
+	if min > b.Min {
+		baseValueMin = uint64(min - b.Min)
 	}
 	// Make sure the high value of the BETWEEN does not exceed BitDepth.
-	if max > f.Max {
-		baseValueMax = uint64(f.Max - f.Min)
-	} else if max > f.Min {
-		baseValueMax = uint64(max - f.Min)
+	if max > b.Max {
+		baseValueMax = uint64(b.Max - b.Min)
+	} else if max > b.Min {
+		baseValueMax = uint64(max - b.Min)
 	}
 	return baseValueMin, baseValueMax, false
 }
 
-func ValidateField(f *oField) error {
-	if f.Name == "" {
+func ValidateField(b *bsiGroup) error {
+	if b.Name == "" {
 		return ErrFieldNameRequired
-	} else if !IsValidFieldType(f.Type) {
+	} else if !IsValidFieldType(b.Type) {
 		return ErrInvalidFieldType
-	} else if f.Min > f.Max {
+	} else if b.Min > b.Max {
 		return ErrInvalidFieldRange
 	}
 	return nil
 }
 
-func encodeField(f *oField) *internal.Field {
-	if f == nil {
+func encodeField(b *bsiGroup) *internal.Field {
+	if b == nil {
 		return nil
 	}
 	return &internal.Field{
-		Name: f.Name,
-		Type: f.Type,
-		Min:  int64(f.Min),
-		Max:  int64(f.Max),
+		Name: b.Name,
+		Type: b.Type,
+		Min:  int64(b.Min),
+		Max:  int64(b.Max),
 	}
 }
 
-func decodeField(f *internal.Field) *oField {
-	if f == nil {
+func decodeField(b *internal.Field) *bsiGroup {
+	if b == nil {
 		return nil
 	}
-	return &oField{
-		Name: f.Name,
-		Type: f.Type,
-		Min:  f.Min,
-		Max:  f.Max,
+	return &bsiGroup{
+		Name: b.Name,
+		Type: b.Type,
+		Min:  b.Min,
+		Max:  b.Max,
 	}
 }
 
diff --git a/frame_internal_test.go b/frame_internal_test.go
index f51ad95e9..c52b76658 100644
--- a/frame_internal_test.go
+++ b/frame_internal_test.go
@@ -23,21 +23,21 @@ import (
 
 // Ensure a field can adjust to its baseValue.
 func TestField_BaseValue(t *testing.T) {
-	f0 := &oField{
-		Name: "f0",
+	b0 := &bsiGroup{
+		Name: "b0",
 		Type: FieldTypeInt,
 		Min:  -100,
 		Max:  900,
 	}
-	f1 := &oField{
-		Name: "f1",
+	b1 := &bsiGroup{
+		Name: "b1",
 		Type: FieldTypeInt,
 		Min:  0,
 		Max:  1000,
 	}
 
-	f2 := &oField{
-		Name: "f2",
+	b2 := &bsiGroup{
+		Name: "b2",
 		Type: FieldTypeInt,
 		Min:  100,
 		Max:  1100,
@@ -46,60 +46,60 @@ func TestField_BaseValue(t *testing.T) {
 	t.Run("Normal Condition", func(t *testing.T) {
 
 		for _, tt := range []struct {
-			f             *oField
+			f             *bsiGroup
 			op            pql.Token
 			val           int64
 			expBaseValue  uint64
 			expOutOfRange bool
 		}{
 			// LT
-			{f0, pql.LT, 5, 105, false},
-			{f0, pql.LT, -8, 92, false},
-			{f0, pql.LT, -108, 0, true},
-			{f0, pql.LT, 1005, 1000, false},
-			{f0, pql.LT, 0, 100, false},
+			{b0, pql.LT, 5, 105, false},
+			{b0, pql.LT, -8, 92, false},
+			{b0, pql.LT, -108, 0, true},
+			{b0, pql.LT, 1005, 1000, false},
+			{b0, pql.LT, 0, 100, false},
 
-			{f1, pql.LT, 5, 5, false},
-			{f1, pql.LT, -8, 0, true},
-			{f1, pql.LT, 1005, 1000, false},
-			{f1, pql.LT, 0, 0, false},
+			{b1, pql.LT, 5, 5, false},
+			{b1, pql.LT, -8, 0, true},
+			{b1, pql.LT, 1005, 1000, false},
+			{b1, pql.LT, 0, 0, false},
 
-			{f2, pql.LT, 5, 0, true},
-			{f2, pql.LT, -8, 0, true},
-			{f2, pql.LT, 105, 5, false},
-			{f2, pql.LT, 1105, 1000, false},
+			{b2, pql.LT, 5, 0, true},
+			{b2, pql.LT, -8, 0, true},
+			{b2, pql.LT, 105, 5, false},
+			{b2, pql.LT, 1105, 1000, false},
 
 			// GT
-			{f0, pql.GT, -105, 0, false},
-			{f0, pql.GT, 5, 105, false},
-			{f0, pql.GT, 905, 0, true},
-			{f0, pql.GT, 0, 100, false},
+			{b0, pql.GT, -105, 0, false},
+			{b0, pql.GT, 5, 105, false},
+			{b0, pql.GT, 905, 0, true},
+			{b0, pql.GT, 0, 100, false},
 
-			{f1, pql.GT, 5, 5, false},
-			{f1, pql.GT, -8, 0, false},
-			{f1, pql.GT, 1005, 0, true},
-			{f1, pql.GT, 0, 0, false},
+			{b1, pql.GT, 5, 5, false},
+			{b1, pql.GT, -8, 0, false},
+			{b1, pql.GT, 1005, 0, true},
+			{b1, pql.GT, 0, 0, false},
 
-			{f2, pql.GT, 5, 0, false},
-			{f2, pql.GT, -8, 0, false},
-			{f2, pql.GT, 105, 5, false},
-			{f2, pql.GT, 1105, 0, true},
+			{b2, pql.GT, 5, 0, false},
+			{b2, pql.GT, -8, 0, false},
+			{b2, pql.GT, 105, 5, false},
+			{b2, pql.GT, 1105, 0, true},
 
 			// EQ
-			{f0, pql.EQ, -105, 0, true},
-			{f0, pql.EQ, 5, 105, false},
-			{f0, pql.EQ, 905, 0, true},
-			{f0, pql.EQ, 0, 100, false},
+			{b0, pql.EQ, -105, 0, true},
+			{b0, pql.EQ, 5, 105, false},
+			{b0, pql.EQ, 905, 0, true},
+			{b0, pql.EQ, 0, 100, false},
 
-			{f1, pql.EQ, 5, 5, false},
-			{f1, pql.EQ, -8, 0, true},
-			{f1, pql.EQ, 1005, 0, true},
-			{f1, pql.EQ, 0, 0, false},
+			{b1, pql.EQ, 5, 5, false},
+			{b1, pql.EQ, -8, 0, true},
+			{b1, pql.EQ, 1005, 0, true},
+			{b1, pql.EQ, 0, 0, false},
 
-			{f2, pql.EQ, 5, 0, true},
-			{f2, pql.EQ, -8, 0, true},
-			{f2, pql.EQ, 105, 5, false},
-			{f2, pql.EQ, 1105, 0, true},
+			{b2, pql.EQ, 5, 0, true},
+			{b2, pql.EQ, -8, 0, true},
+			{b2, pql.EQ, 105, 5, false},
+			{b2, pql.EQ, 1105, 0, true},
 		} {
 			bv, oor := tt.f.BaseValue(tt.op, tt.val)
 			if oor != tt.expOutOfRange {
@@ -112,7 +112,7 @@ func TestField_BaseValue(t *testing.T) {
 
 	t.Run("Betwween Condition", func(t *testing.T) {
 		for _, tt := range []struct {
-			f               *oField
+			f               *bsiGroup
 			predMin         int64
 			predMax         int64
 			expBaseValueMin uint64
@@ -120,23 +120,23 @@ func TestField_BaseValue(t *testing.T) {
 			expOutOfRange   bool
 		}{
 
-			{f0, -205, -105, 0, 0, true},
-			{f0, -105, 80, 0, 180, false},
-			{f0, 5, 20, 105, 120, false},
-			{f0, 20, 1005, 120, 1000, false},
-			{f0, 1005, 2000, 0, 0, true},
+			{b0, -205, -105, 0, 0, true},
+			{b0, -105, 80, 0, 180, false},
+			{b0, 5, 20, 105, 120, false},
+			{b0, 20, 1005, 120, 1000, false},
+			{b0, 1005, 2000, 0, 0, true},
 
-			{f1, -105, -5, 0, 0, true},
-			{f1, -5, 20, 0, 20, false},
-			{f1, 5, 20, 5, 20, false},
-			{f1, 20, 1005, 20, 1000, false},
-			{f1, 1005, 2000, 0, 0, true},
+			{b1, -105, -5, 0, 0, true},
+			{b1, -5, 20, 0, 20, false},
+			{b1, 5, 20, 5, 20, false},
+			{b1, 20, 1005, 20, 1000, false},
+			{b1, 1005, 2000, 0, 0, true},
 
-			{f2, 5, 95, 0, 0, true},
-			{f2, 95, 120, 0, 20, false},
-			{f2, 105, 120, 5, 20, false},
-			{f2, 120, 1105, 20, 1000, false},
-			{f2, 1105, 2000, 0, 0, true},
+			{b2, 5, 95, 0, 0, true},
+			{b2, 95, 120, 0, 20, false},
+			{b2, 105, 120, 5, 20, false},
+			{b2, 120, 1105, 20, 1000, false},
+			{b2, 1105, 2000, 0, 0, true},
 		} {
 			min, max, oor := tt.f.BaseValueBetween(tt.predMin, tt.predMax)
 			if oor != tt.expOutOfRange {

From 63e41b912b253313dd57af75140520a21c6209d2 Mon Sep 17 00:00:00 2001
From: Travis Turner <travis@pilosa.com>
Date: Mon, 4 Jun 2018 15:45:52 -0500
Subject: [PATCH 2/9] rename Frame.fields to Frame.bsiGroups

---
 frame.go | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/frame.go b/frame.go
index 4fa755e62..6ad64a352 100644
--- a/frame.go
+++ b/frame.go
@@ -64,7 +64,7 @@ type Frame struct {
 	// Frame options.
 	options FrameOptions
 
-	fields []*bsiGroup
+	bsiGroups []*bsiGroup
 
 	Logger Logger
 }
@@ -382,9 +382,9 @@ func (f *Frame) Close() error {
 func (f *Frame) Field(name string) *bsiGroup {
 	f.mu.RLock()
 	defer f.mu.RUnlock()
-	for _, field := range f.fields {
-		if field.Name == name {
-			return field
+	for _, bsig := range f.bsiGroups {
+		if bsig.Name == name {
+			return bsig
 		}
 	}
 	return nil
@@ -392,8 +392,8 @@ func (f *Frame) Field(name string) *bsiGroup {
 
 // hasField returns true if a field exists on the frame.
 func (f *Frame) hasField(name string) bool {
-	for _, fld := range f.fields {
-		if fld.Name == name {
+	for _, bsig := range f.bsiGroups {
+		if bsig.Name == name {
 			return true
 		}
 	}
@@ -422,11 +422,11 @@ func (f *Frame) addField(bsig *bsiGroup) error {
 	}
 
 	// Add bsiGroup to list.
-	f.fields = append(f.fields, bsig)
+	f.bsiGroups = append(f.bsiGroups, bsig)
 
 	// Sort fields by name.
-	sort.Slice(f.fields, func(i, j int) bool {
-		return f.fields[i].Name < f.fields[j].Name
+	sort.Slice(f.bsiGroups, func(i, j int) bool {
+		return f.bsiGroups[i].Name < f.bsiGroups[j].Name
 	})
 
 	return nil
@@ -459,10 +459,10 @@ func (f *Frame) DeleteField(name string) error {
 
 // deleteField removes a single field from fields.
 func (f *Frame) deleteField(name string) error {
-	for i, field := range f.fields {
-		if field.Name == name {
-			copy(f.fields[i:], f.fields[i+1:])
-			f.fields, f.fields[len(f.fields)-1] = f.fields[:len(f.fields)-1], nil
+	for i, bsig := range f.bsiGroups {
+		if bsig.Name == name {
+			copy(f.bsiGroups[i:], f.bsiGroups[i+1:])
+			f.bsiGroups, f.bsiGroups[len(f.bsiGroups)-1] = f.bsiGroups[:len(f.bsiGroups)-1], nil
 			return nil
 		}
 	}

From 5d39ba25dfac9731d79fc02c00f329ce8461ded1 Mon Sep 17 00:00:00 2001
From: Travis Turner <travis@pilosa.com>
Date: Mon, 4 Jun 2018 15:49:02 -0500
Subject: [PATCH 3/9] rename FieldTypeInt to bsiGroupTypeInt

---
 frame.go               | 8 ++++----
 frame_internal_test.go | 6 +++---
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/frame.go b/frame.go
index 6ad64a352..26d1bdf3f 100644
--- a/frame.go
+++ b/frame.go
@@ -328,7 +328,7 @@ func (f *Frame) applyOptions(opt FrameOptions) error {
 		// Create new bsiGroup.
 		bsig := &bsiGroup{
 			Name: f.name,
-			Type: FieldTypeInt,
+			Type: bsiGroupTypeInt,
 			Min:  opt.Min,
 			Max:  opt.Max,
 		}
@@ -1070,14 +1070,14 @@ func decodeFrameOptions(options *internal.FrameMeta) *FrameOptions {
 	}
 }
 
-// List of field data types.
+// List of bsiGroup types.
 const (
-	FieldTypeInt = "int"
+	bsiGroupTypeInt = "int"
 )
 
 func IsValidFieldType(v string) bool {
 	switch v {
-	case FieldTypeInt:
+	case bsiGroupTypeInt:
 		return true
 	default:
 		return false
diff --git a/frame_internal_test.go b/frame_internal_test.go
index c52b76658..749e4e720 100644
--- a/frame_internal_test.go
+++ b/frame_internal_test.go
@@ -25,20 +25,20 @@ import (
 func TestField_BaseValue(t *testing.T) {
 	b0 := &bsiGroup{
 		Name: "b0",
-		Type: FieldTypeInt,
+		Type: bsiGroupTypeInt,
 		Min:  -100,
 		Max:  900,
 	}
 	b1 := &bsiGroup{
 		Name: "b1",
-		Type: FieldTypeInt,
+		Type: bsiGroupTypeInt,
 		Min:  0,
 		Max:  1000,
 	}
 
 	b2 := &bsiGroup{
 		Name: "b2",
-		Type: FieldTypeInt,
+		Type: bsiGroupTypeInt,
 		Min:  100,
 		Max:  1100,
 	}

From 54d94f1acaf6ff60e5db769027ecd24a0fc188b6 Mon Sep 17 00:00:00 2001
From: Travis Turner <travis@pilosa.com>
Date: Mon, 4 Jun 2018 16:03:42 -0500
Subject: [PATCH 4/9] rename CreateField to createBSIGroup

---
 api.go    |  2 +-
 frame.go  | 12 ++++++------
 server.go |  2 +-
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/api.go b/api.go
index 9a50a3542..0dc153380 100644
--- a/api.go
+++ b/api.go
@@ -501,7 +501,7 @@ func (api *API) CreateField(ctx context.Context, indexName string, frameName str
 	}
 
 	// Create new bsiGroup.
-	if err := f.CreateField(bsig); err != nil {
+	if err := f.createBSIGroup(bsig); err != nil {
 		return errors.Wrap(err, "creating bsigroup")
 	}
 
diff --git a/frame.go b/frame.go
index 26d1bdf3f..fc52bf3d2 100644
--- a/frame.go
+++ b/frame.go
@@ -333,10 +333,10 @@ func (f *Frame) applyOptions(opt FrameOptions) error {
 			Max:  opt.Max,
 		}
 		// Validate bsiGroup.
-		if err := ValidateField(bsig); err != nil {
+		if err := bsig.validate(); err != nil {
 			return err
 		}
-		if err := f.CreateField(bsig); err != nil {
+		if err := f.createBSIGroup(bsig); err != nil {
 			return errors.Wrap(err, "creating bsigroup")
 		}
 	case FrameTypeTime:
@@ -400,8 +400,8 @@ func (f *Frame) hasField(name string) bool {
 	return false
 }
 
-// CreateField creates a new field on the frame.
-func (f *Frame) CreateField(bsig *bsiGroup) error {
+// createBSIGroup creates a new field on the frame.
+func (f *Frame) createBSIGroup(bsig *bsiGroup) error {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 
@@ -415,7 +415,7 @@ func (f *Frame) CreateField(bsig *bsiGroup) error {
 
 // addField adds a single field to fields.
 func (f *Frame) addField(bsig *bsiGroup) error {
-	if err := ValidateField(bsig); err != nil {
+	if err := bsig.validate(); err != nil {
 		return errors.Wrap(err, "validating bsigroup")
 	} else if f.hasField(bsig.Name) {
 		return ErrFieldExists
@@ -1156,7 +1156,7 @@ func (b *bsiGroup) BaseValueBetween(min, max int64) (baseValueMin, baseValueMax
 	return baseValueMin, baseValueMax, false
 }
 
-func ValidateField(b *bsiGroup) error {
+func (b *bsiGroup) validate() error {
 	if b.Name == "" {
 		return ErrFieldNameRequired
 	} else if !IsValidFieldType(b.Type) {
diff --git a/server.go b/server.go
index 320fd174c..e7c566cbf 100644
--- a/server.go
+++ b/server.go
@@ -473,7 +473,7 @@ func (s *Server) ReceiveMessage(pb proto.Message) error {
 	case *internal.CreateFieldMessage:
 		f := s.Holder.Frame(obj.Index, obj.Frame)
 		field := decodeField(obj.Field)
-		if err := f.CreateField(field); err != nil {
+		if err := f.createBSIGroup(field); err != nil {
 			return err
 		}
 	case *internal.DeleteFieldMessage:

From b10463485e03b04e3c0544940476cbd9ca179e9b Mon Sep 17 00:00:00 2001
From: Travis Turner <travis@pilosa.com>
Date: Mon, 4 Jun 2018 16:06:41 -0500
Subject: [PATCH 5/9] rename Frame.Field() to Frame.bsiGroup()

---
 executor.go | 12 ++++++------
 frame.go    | 20 ++++++++++----------
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/executor.go b/executor.go
index 589b0ace5..25d902591 100644
--- a/executor.go
+++ b/executor.go
@@ -381,7 +381,7 @@ func (e *Executor) executeSumCountSlice(ctx context.Context, index string, c *pq
 		return ValCount{}, nil
 	}
 
-	field := frame.Field(fieldName)
+	field := frame.bsiGroup(fieldName)
 	if field == nil {
 		return ValCount{}, nil
 	}
@@ -420,7 +420,7 @@ func (e *Executor) executeFieldMinSlice(ctx context.Context, index string, c *pq
 		return ValCount{}, nil
 	}
 
-	field := frame.Field(fieldName)
+	field := frame.bsiGroup(fieldName)
 	if field == nil {
 		return ValCount{}, nil
 	}
@@ -459,7 +459,7 @@ func (e *Executor) executeFieldMaxSlice(ctx context.Context, index string, c *pq
 		return ValCount{}, nil
 	}
 
-	field := frame.Field(fieldName)
+	field := frame.bsiGroup(fieldName)
 	if field == nil {
 		return ValCount{}, nil
 	}
@@ -800,7 +800,7 @@ func (e *Executor) executeFieldRangeSlice(ctx context.Context, index string, c *
 	// Handle `!= null`.
 	if cond.Op == pql.NEQ && cond.Value == nil {
 		// Find field.
-		field := f.Field(fieldName)
+		field := f.bsiGroup(fieldName)
 		if field == nil {
 			return nil, ErrFieldNotFound
 		}
@@ -830,7 +830,7 @@ func (e *Executor) executeFieldRangeSlice(ctx context.Context, index string, c *
 		// here is because we need the call to be slice-specific.
 
 		// Find field.
-		field := f.Field(fieldName)
+		field := f.bsiGroup(fieldName)
 		if field == nil {
 			return nil, ErrFieldNotFound
 		}
@@ -863,7 +863,7 @@ func (e *Executor) executeFieldRangeSlice(ctx context.Context, index string, c *
 		}
 
 		// Find field.
-		field := f.Field(fieldName)
+		field := f.bsiGroup(fieldName)
 		if field == nil {
 			return nil, ErrFieldNotFound
 		}
diff --git a/frame.go b/frame.go
index fc52bf3d2..b2d893792 100644
--- a/frame.go
+++ b/frame.go
@@ -378,8 +378,8 @@ func (f *Frame) Close() error {
 	return nil
 }
 
-// Field returns a field by name.
-func (f *Frame) Field(name string) *bsiGroup {
+// bsiGroup returns a field by name.
+func (f *Frame) bsiGroup(name string) *bsiGroup {
 	f.mu.RLock()
 	defer f.mu.RUnlock()
 	for _, bsig := range f.bsiGroups {
@@ -706,7 +706,7 @@ func (f *Frame) ClearBit(name string, rowID, colID uint64, t *time.Time) (change
 
 // FieldValue reads a field value for a column.
 func (f *Frame) FieldValue(columnID uint64, name string) (value int64, exists bool, err error) {
-	field := f.Field(name)
+	field := f.bsiGroup(name)
 	if field == nil {
 		return 0, false, ErrFieldNotFound
 	}
@@ -729,7 +729,7 @@ func (f *Frame) FieldValue(columnID uint64, name string) (value int64, exists bo
 // 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(f.name)
+	field := f.bsiGroup(f.name)
 	if field == nil {
 		return false, ErrFieldNotFound
 	} else if value < field.Min {
@@ -753,7 +753,7 @@ func (f *Frame) SetValue(columnID uint64, value int64) (changed bool, err error)
 // FieldSum returns the sum and count for a field.
 // An optional filtering row can be provided.
 func (f *Frame) FieldSum(filter *Row, name string) (sum, count int64, err error) {
-	field := f.Field(name)
+	field := f.bsiGroup(name)
 	if field == nil {
 		return 0, 0, ErrFieldNotFound
 	}
@@ -773,7 +773,7 @@ func (f *Frame) FieldSum(filter *Row, name string) (sum, count int64, err error)
 // FieldMin returns the min for a field.
 // An optional filtering row can be provided.
 func (f *Frame) FieldMin(filter *Row, name string) (min, count int64, err error) {
-	field := f.Field(name)
+	field := f.bsiGroup(name)
 	if field == nil {
 		return 0, 0, ErrFieldNotFound
 	}
@@ -793,7 +793,7 @@ func (f *Frame) FieldMin(filter *Row, name string) (min, count int64, err error)
 // FieldMax returns the max for a field.
 // An optional filtering row can be provided.
 func (f *Frame) FieldMax(filter *Row, name string) (max, count int64, err error) {
-	field := f.Field(name)
+	field := f.bsiGroup(name)
 	if field == nil {
 		return 0, 0, ErrFieldNotFound
 	}
@@ -812,7 +812,7 @@ func (f *Frame) FieldMax(filter *Row, name string) (max, count int64, err error)
 
 func (f *Frame) FieldRange(name string, op pql.Token, predicate int64) (*Row, error) {
 	// Retrieve and validate field.
-	field := f.Field(name)
+	field := f.bsiGroup(name)
 	if field == nil {
 		return nil, ErrFieldNotFound
 	} else if predicate < field.Min || predicate > field.Max {
@@ -835,7 +835,7 @@ func (f *Frame) FieldRange(name string, op pql.Token, predicate int64) (*Row, er
 
 func (f *Frame) FieldRangeBetween(name string, predicateMin, predicateMax int64) (*Row, error) {
 	// Retrieve and validate field.
-	field := f.Field(name)
+	field := f.bsiGroup(name)
 	if field == nil {
 		return nil, ErrFieldNotFound
 	} else if predicateMin > predicateMax {
@@ -917,7 +917,7 @@ func (f *Frame) Import(rowIDs, columnIDs []uint64, timestamps []*time.Time) erro
 func (f *Frame) ImportValue(fieldName string, columnIDs []uint64, values []int64) error {
 	viewName := ViewFieldPrefix + fieldName
 	// Get the field so we know bitDepth.
-	field := f.Field(fieldName)
+	field := f.bsiGroup(fieldName)
 	if field == nil {
 		return fmt.Errorf("Field does not exist: %s", fieldName)
 	}

From dcf4daf24e5285296571b5a21d09347345a2367d Mon Sep 17 00:00:00 2001
From: Travis Turner <travis@pilosa.com>
Date: Mon, 4 Jun 2018 16:47:08 -0500
Subject: [PATCH 6/9] rename a lot of *Field cases to *BSIGroup

---
 executor.go      | 20 +++++------
 executor_test.go |  2 +-
 frame.go         | 89 ++++++++++++++++++++++++------------------------
 frame_test.go    |  6 ++--
 pilosa.go        | 20 +++++------
 view.go          |  4 +--
 6 files changed, 71 insertions(+), 70 deletions(-)

diff --git a/executor.go b/executor.go
index 25d902591..43b44c315 100644
--- a/executor.go
+++ b/executor.go
@@ -386,7 +386,7 @@ func (e *Executor) executeSumCountSlice(ctx context.Context, index string, c *pq
 		return ValCount{}, nil
 	}
 
-	fragment := e.Holder.Fragment(index, frameName, ViewFieldPrefix+fieldName, slice)
+	fragment := e.Holder.Fragment(index, frameName, viewBSIGroupPrefix+fieldName, slice)
 	if fragment == nil {
 		return ValCount{}, nil
 	}
@@ -425,7 +425,7 @@ func (e *Executor) executeFieldMinSlice(ctx context.Context, index string, c *pq
 		return ValCount{}, nil
 	}
 
-	fragment := e.Holder.Fragment(index, frameName, ViewFieldPrefix+fieldName, slice)
+	fragment := e.Holder.Fragment(index, frameName, viewBSIGroupPrefix+fieldName, slice)
 	if fragment == nil {
 		return ValCount{}, nil
 	}
@@ -464,7 +464,7 @@ func (e *Executor) executeFieldMaxSlice(ctx context.Context, index string, c *pq
 		return ValCount{}, nil
 	}
 
-	fragment := e.Holder.Fragment(index, frameName, ViewFieldPrefix+fieldName, slice)
+	fragment := e.Holder.Fragment(index, frameName, viewBSIGroupPrefix+fieldName, slice)
 	if fragment == nil {
 		return ValCount{}, nil
 	}
@@ -802,11 +802,11 @@ func (e *Executor) executeFieldRangeSlice(ctx context.Context, index string, c *
 		// Find field.
 		field := f.bsiGroup(fieldName)
 		if field == nil {
-			return nil, ErrFieldNotFound
+			return nil, ErrBSIGroupNotFound
 		}
 
 		// Retrieve fragment.
-		frag := e.Holder.Fragment(index, frame, ViewFieldPrefix+fieldName, slice)
+		frag := e.Holder.Fragment(index, frame, viewBSIGroupPrefix+fieldName, slice)
 		if frag == nil {
 			return NewRow(), nil
 		}
@@ -832,7 +832,7 @@ func (e *Executor) executeFieldRangeSlice(ctx context.Context, index string, c *
 		// Find field.
 		field := f.bsiGroup(fieldName)
 		if field == nil {
-			return nil, ErrFieldNotFound
+			return nil, ErrBSIGroupNotFound
 		}
 
 		baseValueMin, baseValueMax, outOfRange := field.BaseValueBetween(predicates[0], predicates[1])
@@ -841,7 +841,7 @@ func (e *Executor) executeFieldRangeSlice(ctx context.Context, index string, c *
 		}
 
 		// Retrieve fragment.
-		frag := e.Holder.Fragment(index, frame, ViewFieldPrefix+fieldName, slice)
+		frag := e.Holder.Fragment(index, frame, viewBSIGroupPrefix+fieldName, slice)
 		if frag == nil {
 			return NewRow(), nil
 		}
@@ -865,7 +865,7 @@ func (e *Executor) executeFieldRangeSlice(ctx context.Context, index string, c *
 		// Find field.
 		field := f.bsiGroup(fieldName)
 		if field == nil {
-			return nil, ErrFieldNotFound
+			return nil, ErrBSIGroupNotFound
 		}
 
 		baseValue, outOfRange := field.BaseValue(cond.Op, value)
@@ -874,7 +874,7 @@ func (e *Executor) executeFieldRangeSlice(ctx context.Context, index string, c *
 		}
 
 		// Retrieve fragment.
-		frag := e.Holder.Fragment(index, frame, ViewFieldPrefix+fieldName, slice)
+		frag := e.Holder.Fragment(index, frame, viewBSIGroupPrefix+fieldName, slice)
 		if frag == nil {
 			return NewRow(), nil
 		}
@@ -1137,7 +1137,7 @@ func (e *Executor) executeSetValue(ctx context.Context, index string, c *pql.Cal
 				return err
 			}
 		default:
-			return ErrInvalidFieldValueType
+			return ErrInvalidBSIGroupValueType
 		}
 		frame.Stats.Count("SetValue", 1, 1.0)
 	}
diff --git a/executor_test.go b/executor_test.go
index a8cce5194..3429529ee 100644
--- a/executor_test.go
+++ b/executor_test.go
@@ -951,7 +951,7 @@ func TestExecutor_Execute_FieldRange(t *testing.T) {
 	})
 
 	t.Run("ErrFieldNotFound", func(t *testing.T) {
-		if _, err := e.Execute(context.Background(), "i", test.MustParse(`Range(frame=foo, bad_field >= 20)`), nil, nil); err != pilosa.ErrFieldNotFound {
+		if _, err := e.Execute(context.Background(), "i", test.MustParse(`Range(frame=foo, bad_field >= 20)`), nil, nil); err != pilosa.ErrBSIGroupNotFound {
 			t.Fatal(err)
 		}
 	})
diff --git a/frame.go b/frame.go
index b2d893792..6e2ef0bf7 100644
--- a/frame.go
+++ b/frame.go
@@ -378,7 +378,7 @@ func (f *Frame) Close() error {
 	return nil
 }
 
-// bsiGroup returns a field by name.
+// bsiGroup returns a bsiGroup by name.
 func (f *Frame) bsiGroup(name string) *bsiGroup {
 	f.mu.RLock()
 	defer f.mu.RUnlock()
@@ -390,8 +390,8 @@ func (f *Frame) bsiGroup(name string) *bsiGroup {
 	return nil
 }
 
-// hasField returns true if a field exists on the frame.
-func (f *Frame) hasField(name string) bool {
+// hasBSIGroup returns true if a bsiGroup exists on the frame.
+func (f *Frame) hasBSIGroup(name string) bool {
 	for _, bsig := range f.bsiGroups {
 		if bsig.Name == name {
 			return true
@@ -400,25 +400,25 @@ func (f *Frame) hasField(name string) bool {
 	return false
 }
 
-// createBSIGroup creates a new field on the frame.
+// createBSIGroup creates a new bsiGroup on the frame.
 func (f *Frame) createBSIGroup(bsig *bsiGroup) error {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 
 	// Append bsiGroup.
-	if err := f.addField(bsig); err != nil {
+	if err := f.addBSIGroup(bsig); err != nil {
 		return err
 	}
 	f.saveMeta()
 	return nil
 }
 
-// addField adds a single field to fields.
-func (f *Frame) addField(bsig *bsiGroup) error {
+// addBSIGroup adds a single bsiGroup to bsiGroups.
+func (f *Frame) addBSIGroup(bsig *bsiGroup) error {
 	if err := bsig.validate(); err != nil {
 		return errors.Wrap(err, "validating bsigroup")
-	} else if f.hasField(bsig.Name) {
-		return ErrFieldExists
+	} else if f.hasBSIGroup(bsig.Name) {
+		return ErrBSIGroupExists
 	}
 
 	// Add bsiGroup to list.
@@ -432,18 +432,19 @@ func (f *Frame) addField(bsig *bsiGroup) error {
 	return nil
 }
 
+// TODO: merge this into the un-exported deleteBSIGroup.
 // DeleteField deletes an existing field on the schema.
 func (f *Frame) DeleteField(name string) error {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 
 	// Remove field.
-	if err := f.deleteField(name); err != nil {
+	if err := f.deleteBSIGroup(name); err != nil {
 		return err
 	}
 
 	// Remove views.
-	viewName := ViewFieldPrefix + name
+	viewName := viewBSIGroupPrefix + name
 	if view := f.views[viewName]; view != nil {
 		delete(f.views, viewName)
 
@@ -457,8 +458,8 @@ func (f *Frame) DeleteField(name string) error {
 	return nil
 }
 
-// deleteField removes a single field from fields.
-func (f *Frame) deleteField(name string) error {
+// deleteBSIGroup removes a single bsiGroup from bsiGroups.
+func (f *Frame) deleteBSIGroup(name string) error {
 	for i, bsig := range f.bsiGroups {
 		if bsig.Name == name {
 			copy(f.bsiGroups[i:], f.bsiGroups[i+1:])
@@ -466,7 +467,7 @@ func (f *Frame) deleteField(name string) error {
 			return nil
 		}
 	}
-	return ErrFieldNotFound
+	return ErrBSIGroupNotFound
 }
 
 // TimeQuantum returns the time quantum for the frame.
@@ -708,11 +709,11 @@ func (f *Frame) ClearBit(name string, rowID, colID uint64, t *time.Time) (change
 func (f *Frame) FieldValue(columnID uint64, name string) (value int64, exists bool, err error) {
 	field := f.bsiGroup(name)
 	if field == nil {
-		return 0, false, ErrFieldNotFound
+		return 0, false, ErrBSIGroupNotFound
 	}
 
 	// Fetch target view.
-	view := f.View(ViewFieldPrefix + name)
+	view := f.View(viewBSIGroupPrefix + name)
 	if view == nil {
 		return 0, false, nil
 	}
@@ -731,15 +732,15 @@ func (f *Frame) SetValue(columnID uint64, value int64) (changed bool, err error)
 	// Fetch field and validate value.
 	field := f.bsiGroup(f.name)
 	if field == nil {
-		return false, ErrFieldNotFound
+		return false, ErrBSIGroupNotFound
 	} else if value < field.Min {
-		return false, ErrFieldValueTooLow
+		return false, ErrBSIGroupValueTooLow
 	} else if value > field.Max {
-		return false, ErrFieldValueTooHigh
+		return false, ErrBSIGroupValueTooHigh
 	}
 
 	// Fetch target view.
-	view, err := f.CreateViewIfNotExists(ViewFieldPrefix + f.name)
+	view, err := f.CreateViewIfNotExists(viewBSIGroupPrefix + f.name)
 	if err != nil {
 		return false, errors.Wrap(err, "creating view")
 	}
@@ -755,10 +756,10 @@ func (f *Frame) SetValue(columnID uint64, value int64) (changed bool, err error)
 func (f *Frame) FieldSum(filter *Row, name string) (sum, count int64, err error) {
 	field := f.bsiGroup(name)
 	if field == nil {
-		return 0, 0, ErrFieldNotFound
+		return 0, 0, ErrBSIGroupNotFound
 	}
 
-	view := f.View(ViewFieldPrefix + name)
+	view := f.View(viewBSIGroupPrefix + name)
 	if view == nil {
 		return 0, 0, nil
 	}
@@ -770,24 +771,24 @@ func (f *Frame) FieldSum(filter *Row, name string) (sum, count int64, err error)
 	return int64(vsum) + (int64(vcount) * field.Min), int64(vcount), nil
 }
 
-// FieldMin returns the min for a field.
+// FieldMin returns the min for a bsiGroup.
 // An optional filtering row can be provided.
 func (f *Frame) FieldMin(filter *Row, name string) (min, count int64, err error) {
-	field := f.bsiGroup(name)
-	if field == nil {
-		return 0, 0, ErrFieldNotFound
+	bsig := f.bsiGroup(name)
+	if bsig == nil {
+		return 0, 0, ErrBSIGroupNotFound
 	}
 
-	view := f.View(ViewFieldPrefix + name)
+	view := f.View(viewBSIGroupPrefix + name)
 	if view == nil {
 		return 0, 0, nil
 	}
 
-	vmin, vcount, err := view.FieldMin(filter, field.BitDepth())
+	vmin, vcount, err := view.FieldMin(filter, bsig.BitDepth())
 	if err != nil {
 		return 0, 0, err
 	}
-	return int64(vmin) + field.Min, int64(vcount), nil
+	return int64(vmin) + bsig.Min, int64(vcount), nil
 }
 
 // FieldMax returns the max for a field.
@@ -795,10 +796,10 @@ func (f *Frame) FieldMin(filter *Row, name string) (min, count int64, err error)
 func (f *Frame) FieldMax(filter *Row, name string) (max, count int64, err error) {
 	field := f.bsiGroup(name)
 	if field == nil {
-		return 0, 0, ErrFieldNotFound
+		return 0, 0, ErrBSIGroupNotFound
 	}
 
-	view := f.View(ViewFieldPrefix + name)
+	view := f.View(viewBSIGroupPrefix + name)
 	if view == nil {
 		return 0, 0, nil
 	}
@@ -814,13 +815,13 @@ func (f *Frame) FieldRange(name string, op pql.Token, predicate int64) (*Row, er
 	// Retrieve and validate field.
 	field := f.bsiGroup(name)
 	if field == nil {
-		return nil, ErrFieldNotFound
+		return nil, ErrBSIGroupNotFound
 	} else if predicate < field.Min || predicate > field.Max {
 		return nil, nil
 	}
 
 	// Retrieve field's view.
-	view := f.View(ViewFieldPrefix + name)
+	view := f.View(viewBSIGroupPrefix + name)
 	if view == nil {
 		return nil, nil
 	}
@@ -837,13 +838,13 @@ func (f *Frame) FieldRangeBetween(name string, predicateMin, predicateMax int64)
 	// Retrieve and validate field.
 	field := f.bsiGroup(name)
 	if field == nil {
-		return nil, ErrFieldNotFound
+		return nil, ErrBSIGroupNotFound
 	} else if predicateMin > predicateMax {
 		return nil, ErrInvalidBetweenValue
 	}
 
 	// Retrieve field's view.
-	view := f.View(ViewFieldPrefix + name)
+	view := f.View(viewBSIGroupPrefix + name)
 	if view == nil {
 		return nil, nil
 	}
@@ -915,7 +916,7 @@ func (f *Frame) Import(rowIDs, columnIDs []uint64, timestamps []*time.Time) erro
 
 // ImportValue bulk imports range-encoded value data.
 func (f *Frame) ImportValue(fieldName string, columnIDs []uint64, values []int64) error {
-	viewName := ViewFieldPrefix + fieldName
+	viewName := viewBSIGroupPrefix + fieldName
 	// Get the field so we know bitDepth.
 	field := f.bsiGroup(fieldName)
 	if field == nil {
@@ -927,9 +928,9 @@ func (f *Frame) ImportValue(fieldName string, columnIDs []uint64, values []int64
 	for i := range columnIDs {
 		columnID, value := columnIDs[i], values[i]
 		if int64(value) > field.Max {
-			return fmt.Errorf("%v, columnID=%v, value=%v", ErrFieldValueTooHigh, columnID, value)
+			return fmt.Errorf("%v, columnID=%v, value=%v", ErrBSIGroupValueTooHigh, columnID, value)
 		} else if int64(value) < field.Min {
-			return fmt.Errorf("%v, columnID=%v, value=%v", ErrFieldValueTooLow, columnID, value)
+			return fmt.Errorf("%v, columnID=%v, value=%v", ErrBSIGroupValueTooLow, columnID, value)
 		}
 
 		// Attach value to each field view.
@@ -1025,7 +1026,7 @@ func (o *FrameOptions) Validate() error {
 		// TODO: cacheType, cacheSize validation
 	case FrameTypeInt:
 		if o.Min > o.Max {
-			return ErrInvalidFieldRange
+			return ErrInvalidBSIGroupRange
 		}
 	case FrameTypeTime:
 		if o.TimeQuantum == "" || !o.TimeQuantum.Valid() {
@@ -1075,7 +1076,7 @@ const (
 	bsiGroupTypeInt = "int"
 )
 
-func IsValidFieldType(v string) bool {
+func isValidBSIGroupType(v string) bool {
 	switch v {
 	case bsiGroupTypeInt:
 		return true
@@ -1158,11 +1159,11 @@ func (b *bsiGroup) BaseValueBetween(min, max int64) (baseValueMin, baseValueMax
 
 func (b *bsiGroup) validate() error {
 	if b.Name == "" {
-		return ErrFieldNameRequired
-	} else if !IsValidFieldType(b.Type) {
-		return ErrInvalidFieldType
+		return ErrBSIGroupNameRequired
+	} else if !isValidBSIGroupType(b.Type) {
+		return ErrInvalidBSIGroupType
 	} else if b.Min > b.Max {
-		return ErrInvalidFieldRange
+		return ErrInvalidBSIGroupRange
 	}
 	return nil
 }
diff --git a/frame_test.go b/frame_test.go
index 9b7f9a336..6cc75f6be 100644
--- a/frame_test.go
+++ b/frame_test.go
@@ -159,7 +159,7 @@ func TestFrame_SetValue(t *testing.T) {
 		}
 
 		// Set value.
-		if _, err := f.SetValue(100, 21); err != pilosa.ErrFieldNotFound {
+		if _, err := f.SetValue(100, 21); err != pilosa.ErrBSIGroupNotFound {
 			t.Fatalf("unexpected error: %s", err)
 		}
 	})
@@ -178,7 +178,7 @@ func TestFrame_SetValue(t *testing.T) {
 		}
 
 		// Set value.
-		if _, err := f.SetValue(100, 15); err != pilosa.ErrFieldValueTooLow {
+		if _, err := f.SetValue(100, 15); err != pilosa.ErrBSIGroupValueTooLow {
 			t.Fatalf("unexpected error: %s", err)
 		}
 	})
@@ -197,7 +197,7 @@ func TestFrame_SetValue(t *testing.T) {
 		}
 
 		// Set value.
-		if _, err := f.SetValue(100, 31); err != pilosa.ErrFieldValueTooHigh {
+		if _, err := f.SetValue(100, 31); err != pilosa.ErrBSIGroupValueTooHigh {
 			t.Fatalf("unexpected error: %s", err)
 		}
 	})
diff --git a/pilosa.go b/pilosa.go
index 7ddea28eb..21bfdd822 100644
--- a/pilosa.go
+++ b/pilosa.go
@@ -36,16 +36,16 @@ var (
 	ErrFrameExists   = errors.New("frame already exists")
 	ErrFrameNotFound = errors.New("frame not found")
 
-	ErrFieldNotFound         = errors.New("field not found")
-	ErrFieldExists           = errors.New("field already exists")
-	ErrFieldNameRequired     = errors.New("field name required")
-	ErrInvalidFieldType      = errors.New("invalid field type")
-	ErrInvalidFieldRange     = errors.New("invalid field range")
-	ErrInvalidFieldValueType = errors.New("invalid field value type")
-	ErrFieldValueTooLow      = errors.New("field value too low")
-	ErrFieldValueTooHigh     = errors.New("field value too high")
-	ErrInvalidRangeOperation = errors.New("invalid range operation")
-	ErrInvalidBetweenValue   = errors.New("invalid value for between operation")
+	ErrBSIGroupNotFound         = errors.New("bsigroup not found")
+	ErrBSIGroupExists           = errors.New("bsigroup already exists")
+	ErrBSIGroupNameRequired     = errors.New("bsigroup name required")
+	ErrInvalidBSIGroupType      = errors.New("invalid bsigroup type")
+	ErrInvalidBSIGroupRange     = errors.New("invalid bsigroup range")
+	ErrInvalidBSIGroupValueType = errors.New("invalid bsigroup value type")
+	ErrBSIGroupValueTooLow      = errors.New("bsigroup value too low")
+	ErrBSIGroupValueTooHigh     = errors.New("bsigroup value too high")
+	ErrInvalidRangeOperation    = errors.New("invalid range operation")
+	ErrInvalidBetweenValue      = errors.New("invalid value for between operation")
 
 	ErrInvalidView      = errors.New("invalid view")
 	ErrInvalidCacheType = errors.New("invalid cache type")
diff --git a/view.go b/view.go
index 0d36faf2a..994a54579 100644
--- a/view.go
+++ b/view.go
@@ -31,7 +31,7 @@ import (
 const (
 	ViewStandard = "standard"
 
-	ViewFieldPrefix = "field_"
+	viewBSIGroupPrefix = "bsig_"
 )
 
 // IsValidView returns true if name is valid.
@@ -98,7 +98,7 @@ func (v *View) Path() string { return v.path }
 func (v *View) Open() error {
 
 	// Never keep a cache for field views.
-	if strings.HasPrefix(v.name, ViewFieldPrefix) {
+	if strings.HasPrefix(v.name, viewBSIGroupPrefix) {
 		v.cacheType = CacheTypeNone
 	}
 

From a6ae39d0b08d5a6c1ffbc5c359fc8c9e644f6d34 Mon Sep 17 00:00:00 2001
From: Travis Turner <travis@pilosa.com>
Date: Mon, 4 Jun 2018 17:18:34 -0500
Subject: [PATCH 7/9] remove cases of Field from frame.go

---
 api.go                 |  19 +--
 broadcast.go           |  20 +--
 client_test.go         |  10 +-
 executor.go            |   4 +-
 executor_test.go       |   4 +-
 frame.go               |  62 ++++-----
 frame_internal_test.go |   4 +-
 frame_test.go          |   4 +-
 internal/private.pb.go | 276 ++++++++++++++++++++---------------------
 internal/private.proto |  11 +-
 server.go              |   8 +-
 11 files changed, 211 insertions(+), 211 deletions(-)

diff --git a/api.go b/api.go
index 0dc153380..e34a9142b 100644
--- a/api.go
+++ b/api.go
@@ -507,10 +507,10 @@ func (api *API) CreateField(ctx context.Context, indexName string, frameName str
 
 	// Send the create bsigroup message to all nodes.
 	err := api.Broadcaster.SendSync(
-		&internal.CreateFieldMessage{
-			Index: indexName,
-			Frame: frameName,
-			Field: encodeField(bsig),
+		&internal.CreateBSIGroupMessage{
+			Index:    indexName,
+			Frame:    frameName,
+			BSIGroup: encodeBSIGroup(bsig),
 		})
 	if err != nil {
 		api.Logger.Printf("problem sending CreateField message: %s", err)
@@ -518,6 +518,7 @@ func (api *API) CreateField(ctx context.Context, indexName string, frameName str
 	return errors.Wrap(err, "sending CreateField message")
 }
 
+// TODO: remove this from the API
 // DeleteField deletes the given field.
 func (api *API) DeleteField(ctx context.Context, indexName string, frameName string, fieldName string) error {
 	if err := api.validate(apiDeleteField); err != nil {
@@ -531,16 +532,16 @@ func (api *API) DeleteField(ctx context.Context, indexName string, frameName str
 	}
 
 	// Delete field.
-	if err := f.DeleteField(fieldName); err != nil {
+	if err := f.deleteBSIGroupAndView(fieldName); err != nil {
 		return errors.Wrap(err, "deleting field")
 	}
 
 	// Send the delete field message to all nodes.
 	err := api.Broadcaster.SendSync(
-		&internal.DeleteFieldMessage{
-			Index: indexName,
-			Frame: frameName,
-			Field: fieldName,
+		&internal.DeleteBSIGroupMessage{
+			Index:    indexName,
+			Frame:    frameName,
+			BSIGroup: fieldName,
 		})
 	if err != nil {
 		api.Logger.Printf("problem sending DeleteField message: %s", err)
diff --git a/broadcast.go b/broadcast.go
index 77b76126d..0840e8c92 100644
--- a/broadcast.go
+++ b/broadcast.go
@@ -127,8 +127,8 @@ const (
 	MessageTypeDeleteFrame
 	MessageTypeCreateView
 	MessageTypeDeleteView
-	MessageTypeCreateField
-	MessageTypeDeleteField
+	MessageTypeCreateBSIGroup
+	MessageTypeDeleteBSIGroup
 	MessageTypeClusterStatus
 	MessageTypeResizeInstruction
 	MessageTypeResizeInstructionComplete
@@ -157,10 +157,10 @@ func MarshalMessage(m proto.Message) ([]byte, error) {
 		typ = MessageTypeCreateView
 	case *internal.DeleteViewMessage:
 		typ = MessageTypeDeleteView
-	case *internal.CreateFieldMessage:
-		typ = MessageTypeCreateField
-	case *internal.DeleteFieldMessage:
-		typ = MessageTypeDeleteField
+	case *internal.CreateBSIGroupMessage:
+		typ = MessageTypeCreateBSIGroup
+	case *internal.DeleteBSIGroupMessage:
+		typ = MessageTypeDeleteBSIGroup
 	case *internal.ClusterStatus:
 		typ = MessageTypeClusterStatus
 	case *internal.ResizeInstruction:
@@ -207,10 +207,10 @@ func UnmarshalMessage(buf []byte) (proto.Message, error) {
 		m = &internal.CreateViewMessage{}
 	case MessageTypeDeleteView:
 		m = &internal.DeleteViewMessage{}
-	case MessageTypeCreateField:
-		m = &internal.CreateFieldMessage{}
-	case MessageTypeDeleteField:
-		m = &internal.DeleteFieldMessage{}
+	case MessageTypeCreateBSIGroup:
+		m = &internal.CreateBSIGroupMessage{}
+	case MessageTypeDeleteBSIGroup:
+		m = &internal.DeleteBSIGroupMessage{}
 	case MessageTypeClusterStatus:
 		m = &internal.ClusterStatus{}
 	case MessageTypeResizeInstruction:
diff --git a/client_test.go b/client_test.go
index 898869f2b..2bb255382 100644
--- a/client_test.go
+++ b/client_test.go
@@ -276,7 +276,7 @@ func TestClient_ImportValue(t *testing.T) {
 	}
 
 	// Verify Sum.
-	sum, cnt, err := frame.FieldSum(nil, fldName)
+	sum, cnt, err := frame.Sum(nil, fldName)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -285,7 +285,7 @@ func TestClient_ImportValue(t *testing.T) {
 	}
 
 	// Verify Min.
-	min, cnt, err := frame.FieldMin(nil, fldName)
+	min, cnt, err := frame.Min(nil, fldName)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -294,11 +294,11 @@ func TestClient_ImportValue(t *testing.T) {
 	}
 
 	// Verify Min with Filter.
-	filter, err := frame.FieldRange(fldName, pql.GT, 40)
+	filter, err := frame.Range(fldName, pql.GT, 40)
 	if err != nil {
 		t.Fatal(err)
 	}
-	min, cnt, err = frame.FieldMin(filter, fldName)
+	min, cnt, err = frame.Min(filter, fldName)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -307,7 +307,7 @@ func TestClient_ImportValue(t *testing.T) {
 	}
 
 	// Verify Max.
-	max, cnt, err := frame.FieldMax(nil, fldName)
+	max, cnt, err := frame.Max(nil, fldName)
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/executor.go b/executor.go
index 43b44c315..b5e19e5b7 100644
--- a/executor.go
+++ b/executor.go
@@ -835,7 +835,7 @@ func (e *Executor) executeFieldRangeSlice(ctx context.Context, index string, c *
 			return nil, ErrBSIGroupNotFound
 		}
 
-		baseValueMin, baseValueMax, outOfRange := field.BaseValueBetween(predicates[0], predicates[1])
+		baseValueMin, baseValueMax, outOfRange := field.baseValueBetween(predicates[0], predicates[1])
 		if outOfRange {
 			return NewRow(), nil
 		}
@@ -868,7 +868,7 @@ func (e *Executor) executeFieldRangeSlice(ctx context.Context, index string, c *
 			return nil, ErrBSIGroupNotFound
 		}
 
-		baseValue, outOfRange := field.BaseValue(cond.Op, value)
+		baseValue, outOfRange := field.baseValue(cond.Op, value)
 		if outOfRange && cond.Op != pql.NEQ {
 			return NewRow(), nil
 		}
diff --git a/executor_test.go b/executor_test.go
index 3429529ee..578ddc11b 100644
--- a/executor_test.go
+++ b/executor_test.go
@@ -290,7 +290,7 @@ func TestExecutor_Execute_SetValue(t *testing.T) {
 		}
 
 		f := hldr.Frame("i", "f")
-		if value, exists, err := f.FieldValue(10, "f"); err != nil {
+		if value, exists, err := f.Value(10, "f"); err != nil {
 			t.Fatal(err)
 		} else if !exists {
 			t.Fatal("expected value to exist")
@@ -298,7 +298,7 @@ func TestExecutor_Execute_SetValue(t *testing.T) {
 			t.Fatalf("unexpected value: %v", value)
 		}
 
-		if value, exists, err := f.FieldValue(100, "f"); err != nil {
+		if value, exists, err := f.Value(100, "f"); err != nil {
 			t.Fatal(err)
 		} else if !exists {
 			t.Fatal("expected value to exist")
diff --git a/frame.go b/frame.go
index 6e2ef0bf7..65d98937c 100644
--- a/frame.go
+++ b/frame.go
@@ -433,8 +433,8 @@ func (f *Frame) addBSIGroup(bsig *bsiGroup) error {
 }
 
 // TODO: merge this into the un-exported deleteBSIGroup.
-// DeleteField deletes an existing field on the schema.
-func (f *Frame) DeleteField(name string) error {
+// deleteBSIGroupAndView deletes an existing field on the schema.
+func (f *Frame) deleteBSIGroupAndView(name string) error {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 
@@ -705,8 +705,8 @@ func (f *Frame) ClearBit(name string, rowID, colID uint64, t *time.Time) (change
 	return changed, nil
 }
 
-// FieldValue reads a field value for a column.
-func (f *Frame) FieldValue(columnID uint64, name string) (value int64, exists bool, err error) {
+// Value reads a bsiGroup value for a column.
+func (f *Frame) Value(columnID uint64, name string) (value int64, exists bool, err error) {
 	field := f.bsiGroup(name)
 	if field == nil {
 		return 0, false, ErrBSIGroupNotFound
@@ -751,9 +751,9 @@ func (f *Frame) SetValue(columnID uint64, value int64) (changed bool, err error)
 	return view.setValue(columnID, field.BitDepth(), baseValue)
 }
 
-// FieldSum returns the sum and count for a field.
+// Sum returns the sum and count for a field.
 // An optional filtering row can be provided.
-func (f *Frame) FieldSum(filter *Row, name string) (sum, count int64, err error) {
+func (f *Frame) Sum(filter *Row, name string) (sum, count int64, err error) {
 	field := f.bsiGroup(name)
 	if field == nil {
 		return 0, 0, ErrBSIGroupNotFound
@@ -771,9 +771,9 @@ func (f *Frame) FieldSum(filter *Row, name string) (sum, count int64, err error)
 	return int64(vsum) + (int64(vcount) * field.Min), int64(vcount), nil
 }
 
-// FieldMin returns the min for a bsiGroup.
+// Min returns the min for a field.
 // An optional filtering row can be provided.
-func (f *Frame) FieldMin(filter *Row, name string) (min, count int64, err error) {
+func (f *Frame) Min(filter *Row, name string) (min, count int64, err error) {
 	bsig := f.bsiGroup(name)
 	if bsig == nil {
 		return 0, 0, ErrBSIGroupNotFound
@@ -791,9 +791,9 @@ func (f *Frame) FieldMin(filter *Row, name string) (min, count int64, err error)
 	return int64(vmin) + bsig.Min, int64(vcount), nil
 }
 
-// FieldMax returns the max for a field.
+// Max returns the max for a field.
 // An optional filtering row can be provided.
-func (f *Frame) FieldMax(filter *Row, name string) (max, count int64, err error) {
+func (f *Frame) Max(filter *Row, name string) (max, count int64, err error) {
 	field := f.bsiGroup(name)
 	if field == nil {
 		return 0, 0, ErrBSIGroupNotFound
@@ -811,7 +811,7 @@ func (f *Frame) FieldMax(filter *Row, name string) (max, count int64, err error)
 	return int64(vmax) + field.Min, int64(vcount), nil
 }
 
-func (f *Frame) FieldRange(name string, op pql.Token, predicate int64) (*Row, error) {
+func (f *Frame) Range(name string, op pql.Token, predicate int64) (*Row, error) {
 	// Retrieve and validate field.
 	field := f.bsiGroup(name)
 	if field == nil {
@@ -826,7 +826,7 @@ func (f *Frame) FieldRange(name string, op pql.Token, predicate int64) (*Row, er
 		return nil, nil
 	}
 
-	baseValue, outOfRange := field.BaseValue(op, predicate)
+	baseValue, outOfRange := field.baseValue(op, predicate)
 	if outOfRange {
 		return NewRow(), nil
 	}
@@ -834,7 +834,7 @@ func (f *Frame) FieldRange(name string, op pql.Token, predicate int64) (*Row, er
 	return view.FieldRange(op, field.BitDepth(), baseValue)
 }
 
-func (f *Frame) FieldRangeBetween(name string, predicateMin, predicateMax int64) (*Row, error) {
+func (f *Frame) RangeBetween(name string, predicateMin, predicateMax int64) (*Row, error) {
 	// Retrieve and validate field.
 	field := f.bsiGroup(name)
 	if field == nil {
@@ -849,7 +849,7 @@ func (f *Frame) FieldRangeBetween(name string, predicateMin, predicateMax int64)
 		return nil, nil
 	}
 
-	baseValueMin, baseValueMax, outOfRange := field.BaseValueBetween(predicateMin, predicateMax)
+	baseValueMin, baseValueMax, outOfRange := field.baseValueBetween(predicateMin, predicateMax)
 	if outOfRange {
 		return NewRow(), nil
 	}
@@ -917,23 +917,23 @@ func (f *Frame) Import(rowIDs, columnIDs []uint64, timestamps []*time.Time) erro
 // ImportValue bulk imports range-encoded value data.
 func (f *Frame) ImportValue(fieldName string, columnIDs []uint64, values []int64) error {
 	viewName := viewBSIGroupPrefix + fieldName
-	// Get the field so we know bitDepth.
-	field := f.bsiGroup(fieldName)
-	if field == nil {
-		return fmt.Errorf("Field does not exist: %s", fieldName)
+	// Get the bsiGroup so we know bitDepth.
+	bsig := f.bsiGroup(fieldName)
+	if bsig == nil {
+		return errors.Wrap(ErrBSIGroupNotFound, fieldName)
 	}
 
 	// Split import data by fragment.
 	dataByFragment := make(map[importKey]importValueData)
 	for i := range columnIDs {
 		columnID, value := columnIDs[i], values[i]
-		if int64(value) > field.Max {
+		if int64(value) > bsig.Max {
 			return fmt.Errorf("%v, columnID=%v, value=%v", ErrBSIGroupValueTooHigh, columnID, value)
-		} else if int64(value) < field.Min {
+		} else if int64(value) < bsig.Min {
 			return fmt.Errorf("%v, columnID=%v, value=%v", ErrBSIGroupValueTooLow, columnID, value)
 		}
 
-		// Attach value to each field view.
+		// Attach value to each bsiGroup view.
 		for _, name := range []string{viewName} {
 			key := importKey{View: name, Slice: columnID / SliceWidth}
 			data := dataByFragment[key]
@@ -960,10 +960,10 @@ func (f *Frame) ImportValue(fieldName string, columnIDs []uint64, values []int64
 
 		baseValues := make([]uint64, len(data.Values))
 		for i, value := range data.Values {
-			baseValues[i] = uint64(value - field.Min)
+			baseValues[i] = uint64(value - bsig.Min)
 		}
 
-		if err := frag.ImportValue(data.ColumnIDs, baseValues, field.BitDepth()); err != nil {
+		if err := frag.ImportValue(data.ColumnIDs, baseValues, bsig.BitDepth()); err != nil {
 			return err
 		}
 	}
@@ -1103,19 +1103,19 @@ func (b *bsiGroup) BitDepth() uint {
 	return 63
 }
 
-// BaseValue adjusts the value to align with the range for Field for a certain
+// baseValue adjusts the value to align with the range for Field for a certain
 // operation type.
 // Note: There is an edge case for GT and LT where this returns a baseValue
 // that does not fully encompass the range.
 // ex: Field.Min = 0, Field.Max = 1023
-// BaseValue(LT, 2000) returns 1023, which will perform "LT 1023" and effectively
+// baseValue(LT, 2000) returns 1023, which will perform "LT 1023" and effectively
 // exclude any columns with value = 1023.
 // Note that in this case (because the range uses the full BitDepth 0 to 1023),
 // we can't simply return 1024.
 // In order to make this work, we effectively need to change the operator to LTE.
 // Executor.executeFieldRangeSlice() takes this into account and returns
 // `frag.FieldNotNull(field.BitDepth())` in such instances.
-func (b *bsiGroup) BaseValue(op pql.Token, value int64) (baseValue uint64, outOfRange bool) {
+func (b *bsiGroup) baseValue(op pql.Token, value int64) (baseValue uint64, outOfRange bool) {
 	if op == pql.GT || op == pql.GTE {
 		if value > b.Max {
 			return baseValue, true
@@ -1139,8 +1139,8 @@ func (b *bsiGroup) BaseValue(op pql.Token, value int64) (baseValue uint64, outOf
 	return baseValue, false
 }
 
-// BaseValueBetween adjusts the min/max value to align with the range for Field.
-func (b *bsiGroup) BaseValueBetween(min, max int64) (baseValueMin, baseValueMax uint64, outOfRange bool) {
+// baseValueBetween adjusts the min/max value to align with the range for Field.
+func (b *bsiGroup) baseValueBetween(min, max int64) (baseValueMin, baseValueMax uint64, outOfRange bool) {
 	if max < b.Min || min > b.Max {
 		return baseValueMin, baseValueMax, true
 	}
@@ -1168,11 +1168,11 @@ func (b *bsiGroup) validate() error {
 	return nil
 }
 
-func encodeField(b *bsiGroup) *internal.Field {
+func encodeBSIGroup(b *bsiGroup) *internal.BSIGroup {
 	if b == nil {
 		return nil
 	}
-	return &internal.Field{
+	return &internal.BSIGroup{
 		Name: b.Name,
 		Type: b.Type,
 		Min:  int64(b.Min),
@@ -1180,7 +1180,7 @@ func encodeField(b *bsiGroup) *internal.Field {
 	}
 }
 
-func decodeField(b *internal.Field) *bsiGroup {
+func decodeBSIGroup(b *internal.BSIGroup) *bsiGroup {
 	if b == nil {
 		return nil
 	}
diff --git a/frame_internal_test.go b/frame_internal_test.go
index 749e4e720..5cba2e84b 100644
--- a/frame_internal_test.go
+++ b/frame_internal_test.go
@@ -101,7 +101,7 @@ func TestField_BaseValue(t *testing.T) {
 			{b2, pql.EQ, 105, 5, false},
 			{b2, pql.EQ, 1105, 0, true},
 		} {
-			bv, oor := tt.f.BaseValue(tt.op, tt.val)
+			bv, oor := tt.f.baseValue(tt.op, tt.val)
 			if oor != tt.expOutOfRange {
 				t.Fatalf("baseValue calculation on %s op %s, expected outOfRange %v, got %v", tt.f.Name, tt.op, tt.expOutOfRange, oor)
 			} else if !reflect.DeepEqual(bv, tt.expBaseValue) {
@@ -138,7 +138,7 @@ func TestField_BaseValue(t *testing.T) {
 			{b2, 120, 1105, 20, 1000, false},
 			{b2, 1105, 2000, 0, 0, true},
 		} {
-			min, max, oor := tt.f.BaseValueBetween(tt.predMin, tt.predMax)
+			min, max, oor := tt.f.baseValueBetween(tt.predMin, tt.predMax)
 			if oor != tt.expOutOfRange {
 				t.Fatalf("baseValueBetween calculation on %s, expected outOfRange %v, got %v", tt.f.Name, tt.expOutOfRange, oor)
 			} else if !reflect.DeepEqual(min, tt.expBaseValueMin) || !reflect.DeepEqual(max, tt.expBaseValueMax) {
diff --git a/frame_test.go b/frame_test.go
index 6cc75f6be..aeae2b7ba 100644
--- a/frame_test.go
+++ b/frame_test.go
@@ -94,7 +94,7 @@ func TestFrame_SetValue(t *testing.T) {
 		}
 
 		// Read value.
-		if value, exists, err := f.FieldValue(100, "f"); err != nil {
+		if value, exists, err := f.Value(100, "f"); err != nil {
 			t.Fatal(err)
 		} else if value != 21 {
 			t.Fatalf("unexpected value: %d", value)
@@ -138,7 +138,7 @@ func TestFrame_SetValue(t *testing.T) {
 		}
 
 		// Read value.
-		if value, exists, err := f.FieldValue(100, "f"); err != nil {
+		if value, exists, err := f.Value(100, "f"); err != nil {
 			t.Fatal(err)
 		} else if value != 23 {
 			t.Fatalf("unexpected value: %d", value)
diff --git a/internal/private.pb.go b/internal/private.pb.go
index 20909445c..4e1aa8589 100644
--- a/internal/private.pb.go
+++ b/internal/private.pb.go
@@ -21,8 +21,8 @@
 		CreateIndexMessage
 		CreateFrameMessage
 		DeleteFrameMessage
-		CreateFieldMessage
-		DeleteFieldMessage
+		CreateBSIGroupMessage
+		DeleteBSIGroupMessage
 		Frame
 		Schema
 		Index
@@ -32,7 +32,7 @@
 		NodeEventMessage
 		NodeStatus
 		ClusterStatus
-		Field
+		BSIGroup
 		CreateViewMessage
 		DeleteViewMessage
 		ResizeInstruction
@@ -366,66 +366,66 @@ func (m *DeleteFrameMessage) GetFrame() string {
 	return ""
 }
 
-type CreateFieldMessage struct {
-	Index string `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
-	Frame string `protobuf:"bytes,2,opt,name=Frame,proto3" json:"Frame,omitempty"`
-	Field *Field `protobuf:"bytes,3,opt,name=Field" json:"Field,omitempty"`
+type CreateBSIGroupMessage struct {
+	Index    string    `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
+	Frame    string    `protobuf:"bytes,2,opt,name=Frame,proto3" json:"Frame,omitempty"`
+	BSIGroup *BSIGroup `protobuf:"bytes,3,opt,name=BSIGroup" json:"BSIGroup,omitempty"`
 }
 
-func (m *CreateFieldMessage) Reset()                    { *m = CreateFieldMessage{} }
-func (m *CreateFieldMessage) String() string            { return proto.CompactTextString(m) }
-func (*CreateFieldMessage) ProtoMessage()               {}
-func (*CreateFieldMessage) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{12} }
+func (m *CreateBSIGroupMessage) Reset()                    { *m = CreateBSIGroupMessage{} }
+func (m *CreateBSIGroupMessage) String() string            { return proto.CompactTextString(m) }
+func (*CreateBSIGroupMessage) ProtoMessage()               {}
+func (*CreateBSIGroupMessage) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{12} }
 
-func (m *CreateFieldMessage) GetIndex() string {
+func (m *CreateBSIGroupMessage) GetIndex() string {
 	if m != nil {
 		return m.Index
 	}
 	return ""
 }
 
-func (m *CreateFieldMessage) GetFrame() string {
+func (m *CreateBSIGroupMessage) GetFrame() string {
 	if m != nil {
 		return m.Frame
 	}
 	return ""
 }
 
-func (m *CreateFieldMessage) GetField() *Field {
+func (m *CreateBSIGroupMessage) GetBSIGroup() *BSIGroup {
 	if m != nil {
-		return m.Field
+		return m.BSIGroup
 	}
 	return nil
 }
 
-type DeleteFieldMessage struct {
-	Index string `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
-	Frame string `protobuf:"bytes,2,opt,name=Frame,proto3" json:"Frame,omitempty"`
-	Field string `protobuf:"bytes,3,opt,name=Field,proto3" json:"Field,omitempty"`
+type DeleteBSIGroupMessage struct {
+	Index    string `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
+	Frame    string `protobuf:"bytes,2,opt,name=Frame,proto3" json:"Frame,omitempty"`
+	BSIGroup string `protobuf:"bytes,3,opt,name=BSIGroup,proto3" json:"BSIGroup,omitempty"`
 }
 
-func (m *DeleteFieldMessage) Reset()                    { *m = DeleteFieldMessage{} }
-func (m *DeleteFieldMessage) String() string            { return proto.CompactTextString(m) }
-func (*DeleteFieldMessage) ProtoMessage()               {}
-func (*DeleteFieldMessage) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{13} }
+func (m *DeleteBSIGroupMessage) Reset()                    { *m = DeleteBSIGroupMessage{} }
+func (m *DeleteBSIGroupMessage) String() string            { return proto.CompactTextString(m) }
+func (*DeleteBSIGroupMessage) ProtoMessage()               {}
+func (*DeleteBSIGroupMessage) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{13} }
 
-func (m *DeleteFieldMessage) GetIndex() string {
+func (m *DeleteBSIGroupMessage) GetIndex() string {
 	if m != nil {
 		return m.Index
 	}
 	return ""
 }
 
-func (m *DeleteFieldMessage) GetFrame() string {
+func (m *DeleteBSIGroupMessage) GetFrame() string {
 	if m != nil {
 		return m.Frame
 	}
 	return ""
 }
 
-func (m *DeleteFieldMessage) GetField() string {
+func (m *DeleteBSIGroupMessage) GetBSIGroup() string {
 	if m != nil {
-		return m.Field
+		return m.BSIGroup
 	}
 	return ""
 }
@@ -678,40 +678,40 @@ func (m *ClusterStatus) GetNodes() []*Node {
 	return nil
 }
 
-type Field struct {
+type BSIGroup struct {
 	Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
 	Type string `protobuf:"bytes,2,opt,name=Type,proto3" json:"Type,omitempty"`
 	Min  int64  `protobuf:"varint,3,opt,name=Min,proto3" json:"Min,omitempty"`
 	Max  int64  `protobuf:"varint,4,opt,name=Max,proto3" json:"Max,omitempty"`
 }
 
-func (m *Field) Reset()                    { *m = Field{} }
-func (m *Field) String() string            { return proto.CompactTextString(m) }
-func (*Field) ProtoMessage()               {}
-func (*Field) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{23} }
+func (m *BSIGroup) Reset()                    { *m = BSIGroup{} }
+func (m *BSIGroup) String() string            { return proto.CompactTextString(m) }
+func (*BSIGroup) ProtoMessage()               {}
+func (*BSIGroup) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{23} }
 
-func (m *Field) GetName() string {
+func (m *BSIGroup) GetName() string {
 	if m != nil {
 		return m.Name
 	}
 	return ""
 }
 
-func (m *Field) GetType() string {
+func (m *BSIGroup) GetType() string {
 	if m != nil {
 		return m.Type
 	}
 	return ""
 }
 
-func (m *Field) GetMin() int64 {
+func (m *BSIGroup) GetMin() int64 {
 	if m != nil {
 		return m.Min
 	}
 	return 0
 }
 
-func (m *Field) GetMax() int64 {
+func (m *BSIGroup) GetMax() int64 {
 	if m != nil {
 		return m.Max
 	}
@@ -997,8 +997,8 @@ func init() {
 	proto.RegisterType((*CreateIndexMessage)(nil), "internal.CreateIndexMessage")
 	proto.RegisterType((*CreateFrameMessage)(nil), "internal.CreateFrameMessage")
 	proto.RegisterType((*DeleteFrameMessage)(nil), "internal.DeleteFrameMessage")
-	proto.RegisterType((*CreateFieldMessage)(nil), "internal.CreateFieldMessage")
-	proto.RegisterType((*DeleteFieldMessage)(nil), "internal.DeleteFieldMessage")
+	proto.RegisterType((*CreateBSIGroupMessage)(nil), "internal.CreateBSIGroupMessage")
+	proto.RegisterType((*DeleteBSIGroupMessage)(nil), "internal.DeleteBSIGroupMessage")
 	proto.RegisterType((*Frame)(nil), "internal.Frame")
 	proto.RegisterType((*Schema)(nil), "internal.Schema")
 	proto.RegisterType((*Index)(nil), "internal.Index")
@@ -1008,7 +1008,7 @@ func init() {
 	proto.RegisterType((*NodeEventMessage)(nil), "internal.NodeEventMessage")
 	proto.RegisterType((*NodeStatus)(nil), "internal.NodeStatus")
 	proto.RegisterType((*ClusterStatus)(nil), "internal.ClusterStatus")
-	proto.RegisterType((*Field)(nil), "internal.Field")
+	proto.RegisterType((*BSIGroup)(nil), "internal.BSIGroup")
 	proto.RegisterType((*CreateViewMessage)(nil), "internal.CreateViewMessage")
 	proto.RegisterType((*DeleteViewMessage)(nil), "internal.DeleteViewMessage")
 	proto.RegisterType((*ResizeInstruction)(nil), "internal.ResizeInstruction")
@@ -1436,7 +1436,7 @@ func (m *DeleteFrameMessage) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func (m *CreateFieldMessage) Marshal() (dAtA []byte, err error) {
+func (m *CreateBSIGroupMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -1446,7 +1446,7 @@ func (m *CreateFieldMessage) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *CreateFieldMessage) MarshalTo(dAtA []byte) (int, error) {
+func (m *CreateBSIGroupMessage) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -1463,11 +1463,11 @@ func (m *CreateFieldMessage) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Frame)))
 		i += copy(dAtA[i:], m.Frame)
 	}
-	if m.Field != nil {
+	if m.BSIGroup != nil {
 		dAtA[i] = 0x1a
 		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Field.Size()))
-		n9, err := m.Field.MarshalTo(dAtA[i:])
+		i = encodeVarintPrivate(dAtA, i, uint64(m.BSIGroup.Size()))
+		n9, err := m.BSIGroup.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
@@ -1476,7 +1476,7 @@ func (m *CreateFieldMessage) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func (m *DeleteFieldMessage) Marshal() (dAtA []byte, err error) {
+func (m *DeleteBSIGroupMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -1486,7 +1486,7 @@ func (m *DeleteFieldMessage) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *DeleteFieldMessage) MarshalTo(dAtA []byte) (int, error) {
+func (m *DeleteBSIGroupMessage) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -1503,11 +1503,11 @@ func (m *DeleteFieldMessage) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Frame)))
 		i += copy(dAtA[i:], m.Frame)
 	}
-	if len(m.Field) > 0 {
+	if len(m.BSIGroup) > 0 {
 		dAtA[i] = 0x1a
 		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
-		i += copy(dAtA[i:], m.Field)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.BSIGroup)))
+		i += copy(dAtA[i:], m.BSIGroup)
 	}
 	return i, nil
 }
@@ -1859,7 +1859,7 @@ func (m *ClusterStatus) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
-func (m *Field) Marshal() (dAtA []byte, err error) {
+func (m *BSIGroup) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalTo(dAtA)
@@ -1869,7 +1869,7 @@ func (m *Field) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Field) MarshalTo(dAtA []byte) (int, error) {
+func (m *BSIGroup) MarshalTo(dAtA []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -2459,7 +2459,7 @@ func (m *DeleteFrameMessage) Size() (n int) {
 	return n
 }
 
-func (m *CreateFieldMessage) Size() (n int) {
+func (m *CreateBSIGroupMessage) Size() (n int) {
 	var l int
 	_ = l
 	l = len(m.Index)
@@ -2470,14 +2470,14 @@ func (m *CreateFieldMessage) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
-	if m.Field != nil {
-		l = m.Field.Size()
+	if m.BSIGroup != nil {
+		l = m.BSIGroup.Size()
 		n += 1 + l + sovPrivate(uint64(l))
 	}
 	return n
 }
 
-func (m *DeleteFieldMessage) Size() (n int) {
+func (m *DeleteBSIGroupMessage) Size() (n int) {
 	var l int
 	_ = l
 	l = len(m.Index)
@@ -2488,7 +2488,7 @@ func (m *DeleteFieldMessage) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
-	l = len(m.Field)
+	l = len(m.BSIGroup)
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
@@ -2642,7 +2642,7 @@ func (m *ClusterStatus) Size() (n int) {
 	return n
 }
 
-func (m *Field) Size() (n int) {
+func (m *BSIGroup) Size() (n int) {
 	var l int
 	_ = l
 	l = len(m.Name)
@@ -4304,7 +4304,7 @@ func (m *DeleteFrameMessage) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
+func (m *CreateBSIGroupMessage) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -4327,10 +4327,10 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: CreateFieldMessage: wiretype end group for non-group")
+			return fmt.Errorf("proto: CreateBSIGroupMessage: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: CreateFieldMessage: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: CreateBSIGroupMessage: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -4393,7 +4393,7 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Field", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field BSIGroup", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -4417,10 +4417,10 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Field == nil {
-				m.Field = &Field{}
+			if m.BSIGroup == nil {
+				m.BSIGroup = &BSIGroup{}
 			}
-			if err := m.Field.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.BSIGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -4445,7 +4445,7 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *DeleteFieldMessage) Unmarshal(dAtA []byte) error {
+func (m *DeleteBSIGroupMessage) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -4468,10 +4468,10 @@ func (m *DeleteFieldMessage) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: DeleteFieldMessage: wiretype end group for non-group")
+			return fmt.Errorf("proto: DeleteBSIGroupMessage: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: DeleteFieldMessage: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: DeleteBSIGroupMessage: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -4534,7 +4534,7 @@ func (m *DeleteFieldMessage) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Field", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field BSIGroup", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -4559,7 +4559,7 @@ func (m *DeleteFieldMessage) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Field = string(dAtA[iNdEx:postIndex])
+			m.BSIGroup = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -5671,7 +5671,7 @@ func (m *ClusterStatus) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *Field) Unmarshal(dAtA []byte) error {
+func (m *BSIGroup) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -5694,10 +5694,10 @@ func (m *Field) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: Field: wiretype end group for non-group")
+			return fmt.Errorf("proto: BSIGroup: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Field: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: BSIGroup: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -7075,70 +7075,70 @@ var (
 func init() { proto.RegisterFile("private.proto", fileDescriptorPrivate) }
 
 var fileDescriptorPrivate = []byte{
-	// 1029 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcb, 0x6f, 0x1b, 0x45,
-	0x18, 0x67, 0xbd, 0x6b, 0x27, 0xfe, 0x82, 0xd3, 0x64, 0x5a, 0xc2, 0x16, 0xa1, 0x60, 0x46, 0x45,
-	0x18, 0x0e, 0x51, 0x69, 0x2f, 0xbc, 0x2a, 0x45, 0xb1, 0x83, 0x58, 0x44, 0x22, 0x98, 0x4d, 0x7a,
-	0x40, 0xe2, 0x30, 0xb5, 0x47, 0xe9, 0x2a, 0xeb, 0x1d, 0xb3, 0x3b, 0x9b, 0xc4, 0x3d, 0x70, 0x85,
-	0x0b, 0x77, 0xc4, 0x8d, 0xff, 0x86, 0x23, 0x7f, 0x02, 0x0a, 0xff, 0x08, 0x9a, 0x6f, 0x66, 0x1f,
-	0xf1, 0xa3, 0xa9, 0x4c, 0x6f, 0xf3, 0xbd, 0x5f, 0xbf, 0x6f, 0x66, 0xa0, 0x33, 0x49, 0xa3, 0x0b,
-	0xae, 0xc4, 0xde, 0x24, 0x95, 0x4a, 0x92, 0xf5, 0x28, 0x51, 0x22, 0x4d, 0x78, 0x4c, 0x37, 0xa0,
-	0x1d, 0x24, 0x23, 0x71, 0x75, 0x24, 0x14, 0xa7, 0x7f, 0x3a, 0xd0, 0xfe, 0x2a, 0xe5, 0x63, 0xa1,
-	0x29, 0xf2, 0x2e, 0xb4, 0xfb, 0x7c, 0xf8, 0x5c, 0x9c, 0x4c, 0x27, 0xc2, 0x77, 0xbb, 0x4e, 0xaf,
-	0xcd, 0x2a, 0x46, 0x29, 0x0d, 0xa3, 0x17, 0xc2, 0xf7, 0xba, 0x4e, 0xaf, 0xc3, 0x2a, 0x06, 0xe9,
-	0xc2, 0xc6, 0x49, 0x34, 0x16, 0xdf, 0xe7, 0x3c, 0x51, 0xf9, 0xd8, 0x6f, 0xa2, 0x75, 0x9d, 0x45,
-	0x08, 0x78, 0xe8, 0x78, 0x1d, 0x45, 0x78, 0x26, 0x5b, 0xe0, 0x1e, 0x45, 0x89, 0xdf, 0xee, 0x3a,
-	0x3d, 0x97, 0xe9, 0x23, 0x72, 0xf8, 0x95, 0x0f, 0x96, 0xc3, 0xaf, 0x28, 0x85, 0xcd, 0x60, 0x3c,
-	0x91, 0xa9, 0x62, 0x22, 0x9b, 0xc8, 0x24, 0x43, 0xab, 0xc3, 0x34, 0xf5, 0x1d, 0x74, 0xa4, 0x8f,
-	0xf4, 0x67, 0xd8, 0x3a, 0x88, 0xe5, 0xf0, 0x7c, 0xc0, 0x15, 0x67, 0xe2, 0xa7, 0x5c, 0x64, 0x8a,
-	0xdc, 0x83, 0x26, 0x16, 0x6a, 0xf5, 0x0c, 0xa1, 0xb9, 0x58, 0xb0, 0xdf, 0x30, 0x5c, 0x24, 0x34,
-	0x17, 0xed, 0xb1, 0x6a, 0x8f, 0x19, 0x42, 0x73, 0xc3, 0x38, 0x1a, 0x9a, 0x6a, 0x3d, 0x66, 0x08,
-	0x5d, 0xc7, 0xd3, 0x48, 0x5c, 0xda, 0x12, 0xf1, 0x4c, 0x03, 0xd8, 0xae, 0xc5, 0xb7, 0x69, 0xee,
-	0x40, 0x8b, 0xc9, 0xcb, 0x60, 0x90, 0xf9, 0x4e, 0xd7, 0xed, 0x79, 0xcc, 0x52, 0xd8, 0x48, 0x19,
-	0xe7, 0xe3, 0x44, 0x8b, 0x1a, 0x28, 0xaa, 0x18, 0xf4, 0x3e, 0x34, 0xb1, 0xab, 0xba, 0xca, 0xca,
-	0x56, 0x1f, 0xe9, 0x2f, 0x0e, 0xb4, 0x8f, 0xf8, 0x15, 0xa6, 0x91, 0x91, 0x27, 0xb0, 0x1e, 0x2a,
-	0x9e, 0x8c, 0x78, 0x3a, 0x42, 0xa5, 0x8d, 0x47, 0xef, 0xef, 0x15, 0x53, 0xde, 0x2b, 0xd5, 0xf6,
-	0x0a, 0x9d, 0xc3, 0x44, 0xa5, 0x53, 0x56, 0x9a, 0xbc, 0xf3, 0x05, 0x74, 0x6e, 0x88, 0x74, 0xbc,
-	0x73, 0x31, 0x2d, 0xba, 0x7a, 0x2e, 0xa6, 0xba, 0xfe, 0x0b, 0x1e, 0xe7, 0xa6, 0x57, 0x1e, 0x33,
-	0xc4, 0xe7, 0x8d, 0x4f, 0x1d, 0xba, 0x0f, 0xa4, 0x9f, 0x0a, 0xae, 0x04, 0x06, 0x39, 0x12, 0x59,
-	0xc6, 0xcf, 0xc4, 0xf2, 0x8e, 0x9b, 0x2e, 0x36, 0x6a, 0x5d, 0xa4, 0x1f, 0x03, 0x19, 0x88, 0x58,
-	0x28, 0x61, 0xc1, 0xf8, 0x12, 0x0f, 0x34, 0x2c, 0xa2, 0xdd, 0xae, 0x4b, 0x3e, 0x04, 0x4f, 0x63,
-	0x19, 0x83, 0x6d, 0x3c, 0xba, 0x5b, 0x75, 0xa4, 0x04, 0x3d, 0x43, 0x05, 0x1a, 0x15, 0x4e, 0x2d,
-	0xfe, 0x6f, 0x29, 0x61, 0x01, 0x68, 0x8a, 0x50, 0xee, 0x6c, 0xa8, 0x72, 0xa3, 0x6c, 0xa8, 0xfd,
-	0xa2, 0xd6, 0x55, 0x43, 0xd1, 0xb3, 0x32, 0xd9, 0x48, 0xc4, 0xa3, 0x55, 0x92, 0xfd, 0x00, 0x9a,
-	0x68, 0x6b, 0xb3, 0xbd, 0x53, 0xcb, 0x56, 0xb3, 0x99, 0x91, 0xd2, 0xa7, 0x65, 0xaa, 0xab, 0x06,
-	0xba, 0x57, 0x0f, 0xd4, 0x2e, 0xfc, 0xfe, 0x60, 0x75, 0xf5, 0xf6, 0x1c, 0x6b, 0x1b, 0xe3, 0x09,
-	0xcf, 0xcb, 0x67, 0x36, 0xd3, 0x48, 0xed, 0x5b, 0xaf, 0x5b, 0xe6, 0xbb, 0x5d, 0x57, 0xfb, 0x46,
-	0x82, 0x3e, 0x86, 0x56, 0x38, 0x7c, 0x2e, 0xc6, 0x9c, 0x7c, 0x04, 0x6b, 0x98, 0x9a, 0xc8, 0xec,
-	0x46, 0xdc, 0x99, 0x99, 0x3f, 0x2b, 0xe4, 0x74, 0x60, 0x4b, 0x5a, 0x92, 0x50, 0x0b, 0x43, 0x67,
-	0xbe, 0x37, 0xeb, 0x06, 0xf9, 0xcc, 0x8a, 0xe9, 0x21, 0xb8, 0xa7, 0x2c, 0xd0, 0x9b, 0x8e, 0x19,
-	0x14, 0x5e, 0x2c, 0xa5, 0x7d, 0x7f, 0x2d, 0x33, 0x65, 0x1b, 0x84, 0x67, 0xcd, 0xfb, 0x4e, 0xa6,
-	0x0a, 0xdb, 0xd3, 0x61, 0x78, 0xa6, 0x3f, 0x82, 0x77, 0x2c, 0x47, 0x82, 0x6c, 0x42, 0x23, 0x18,
-	0x58, 0x1f, 0x8d, 0x60, 0x40, 0xde, 0x43, 0xf7, 0xb6, 0x2f, 0x9d, 0x2a, 0x89, 0x53, 0x16, 0x30,
-	0x0c, 0xfc, 0x00, 0x3a, 0x41, 0xd6, 0x97, 0x32, 0x1d, 0x45, 0x09, 0x57, 0x32, 0x45, 0xaf, 0xeb,
-	0xec, 0x26, 0x93, 0xee, 0xc3, 0x96, 0x76, 0x1f, 0x2a, 0xae, 0x4a, 0xf4, 0xed, 0x40, 0x4b, 0xf3,
-	0xca, 0x70, 0x96, 0xc2, 0x6d, 0xd5, 0x7a, 0xc5, 0x50, 0x91, 0xa0, 0xdf, 0x1a, 0x0f, 0x87, 0x17,
-	0x22, 0x51, 0x35, 0x50, 0x20, 0x8d, 0x0e, 0x3a, 0xcc, 0x10, 0x84, 0x9a, 0x52, 0x6c, 0xce, 0x9b,
-	0x55, 0xce, 0x9a, 0xcb, 0x50, 0x46, 0x7f, 0x73, 0x00, 0x8a, 0x84, 0xf2, 0xac, 0x34, 0x71, 0x96,
-	0x9b, 0x90, 0x4f, 0x6a, 0x37, 0xdf, 0x3c, 0x4e, 0x4a, 0x11, 0xab, 0xdd, 0x8f, 0xbd, 0x02, 0x16,
-	0x16, 0xf2, 0x5b, 0x95, 0xbe, 0xe1, 0xdb, 0x31, 0xe9, 0xab, 0xa0, 0xd3, 0x8f, 0xf3, 0x4c, 0x89,
-	0xd4, 0x66, 0xa4, 0x6f, 0x68, 0xc3, 0x28, 0xfb, 0x53, 0x31, 0x16, 0xb7, 0x88, 0x3c, 0x80, 0xa6,
-	0xce, 0xd4, 0x60, 0x73, 0xbe, 0x0c, 0x23, 0xa4, 0xa1, 0xdd, 0x8e, 0x85, 0xb0, 0x2b, 0x5e, 0xc8,
-	0xc6, 0xfc, 0x0b, 0xe9, 0xce, 0xbd, 0x90, 0x5e, 0xf5, 0x42, 0x86, 0xb0, 0x6d, 0x6e, 0x07, 0xbd,
-	0x0f, 0xab, 0xec, 0x6c, 0xf1, 0xa4, 0xb9, 0xb5, 0x27, 0x2d, 0x84, 0x6d, 0x73, 0x13, 0xbc, 0x4e,
-	0xa7, 0x7f, 0x34, 0x60, 0x9b, 0x89, 0x2c, 0x7a, 0x21, 0x82, 0x24, 0x53, 0x69, 0x3e, 0x54, 0x91,
-	0x4c, 0xb4, 0xfd, 0x37, 0xf2, 0x99, 0x6d, 0xb5, 0xcb, 0x0c, 0xf1, 0x2a, 0x48, 0x22, 0x0f, 0x61,
-	0x63, 0x16, 0xfd, 0xf3, 0xaa, 0x75, 0x15, 0xf2, 0x10, 0xd6, 0x42, 0x99, 0xa7, 0xc3, 0x72, 0xb7,
-	0x77, 0x2a, 0x6d, 0x93, 0x99, 0x11, 0xb3, 0x42, 0xad, 0x86, 0xa3, 0xe6, 0xcb, 0x71, 0x44, 0x9e,
-	0xcc, 0xe0, 0xc8, 0x6f, 0xa1, 0xc1, 0xdb, 0x95, 0xc1, 0x0d, 0x31, 0xbb, 0xa9, 0x4d, 0x7f, 0x75,
-	0xe0, 0xcd, 0x7a, 0x0a, 0xaf, 0xb4, 0x18, 0xe5, 0x44, 0x1a, 0x0b, 0x27, 0xe2, 0x2e, 0x9a, 0x88,
-	0x57, 0x4d, 0xa4, 0x7a, 0x9d, 0x9b, 0xf5, 0xd7, 0xf9, 0x1c, 0xee, 0xcf, 0x8d, 0xa9, 0x2f, 0xc7,
-	0x13, 0x8d, 0x87, 0xff, 0x31, 0x2e, 0x7d, 0x65, 0xa4, 0xa9, 0x1d, 0x54, 0x9b, 0x19, 0x82, 0x7e,
-	0x06, 0x6f, 0x85, 0x42, 0xd5, 0x86, 0x54, 0xa0, 0xad, 0x0b, 0xee, 0xb1, 0xb8, 0x5c, 0x52, 0xbe,
-	0x16, 0xd1, 0x2f, 0xc1, 0x3f, 0x9d, 0x8c, 0xb8, 0x12, 0x2b, 0x59, 0x1f, 0xc0, 0xfa, 0x89, 0x9c,
-	0xc8, 0x58, 0x9e, 0x4d, 0x6f, 0x59, 0x79, 0x1f, 0xd6, 0xcc, 0xfd, 0x68, 0x3e, 0x6c, 0x6d, 0x56,
-	0x90, 0xf4, 0xae, 0x06, 0xf4, 0x90, 0xc7, 0xc3, 0x3c, 0xd6, 0x69, 0xe8, 0x9f, 0x5b, 0x76, 0xb0,
-	0xf5, 0xd7, 0xf5, 0xae, 0xf3, 0xf7, 0xf5, 0xae, 0xf3, 0xcf, 0xf5, 0xae, 0xf3, 0xfb, 0xbf, 0xbb,
-	0x6f, 0x3c, 0x6b, 0xe1, 0x37, 0xfc, 0xf1, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x71, 0x97, 0x84,
-	0xb1, 0x97, 0x0b, 0x00, 0x00,
+	// 1038 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0x4d, 0x6f, 0x1b, 0xc5,
+	0x1b, 0xff, 0xaf, 0x77, 0xed, 0xd8, 0x4f, 0xfe, 0x0e, 0xc9, 0x94, 0x84, 0x6d, 0x85, 0x82, 0x19,
+	0x55, 0x22, 0x70, 0xb0, 0x4a, 0x7b, 0xe1, 0xad, 0x52, 0x14, 0x3b, 0xc0, 0x22, 0x12, 0xc1, 0x6c,
+	0xd2, 0x03, 0x12, 0x42, 0x53, 0x7b, 0xd4, 0xae, 0xb2, 0xde, 0x31, 0xbb, 0xb3, 0x49, 0xdc, 0x03,
+	0x57, 0xb8, 0x70, 0x47, 0xdc, 0xf8, 0x36, 0x1c, 0xf9, 0x08, 0x28, 0x7c, 0x11, 0x34, 0xcf, 0xcc,
+	0xbe, 0xc4, 0x2f, 0x4d, 0x95, 0x72, 0x9b, 0xe7, 0xfd, 0xed, 0xf7, 0xcc, 0x0c, 0x74, 0xa7, 0x69,
+	0x74, 0xce, 0x95, 0xe8, 0x4f, 0x53, 0xa9, 0x24, 0x69, 0x47, 0x89, 0x12, 0x69, 0xc2, 0x63, 0xba,
+	0x0e, 0x9d, 0x20, 0x19, 0x8b, 0xcb, 0x23, 0xa1, 0x38, 0xfd, 0xc3, 0x81, 0xce, 0xe7, 0x29, 0x9f,
+	0x08, 0x4d, 0x91, 0xb7, 0xa1, 0x33, 0xe0, 0xa3, 0xe7, 0xe2, 0x64, 0x36, 0x15, 0xbe, 0xdb, 0x73,
+	0xf6, 0x3a, 0xac, 0x62, 0x94, 0xd2, 0x30, 0x7a, 0x21, 0x7c, 0xaf, 0xe7, 0xec, 0x75, 0x59, 0xc5,
+	0x20, 0x3d, 0x58, 0x3f, 0x89, 0x26, 0xe2, 0xdb, 0x9c, 0x27, 0x2a, 0x9f, 0xf8, 0x4d, 0xb4, 0xae,
+	0xb3, 0x08, 0x01, 0x0f, 0x1d, 0xb7, 0x51, 0x84, 0x67, 0xb2, 0x09, 0xee, 0x51, 0x94, 0xf8, 0x9d,
+	0x9e, 0xb3, 0xe7, 0x32, 0x7d, 0x44, 0x0e, 0xbf, 0xf4, 0xc1, 0x72, 0xf8, 0x25, 0xa5, 0xb0, 0x11,
+	0x4c, 0xa6, 0x32, 0x55, 0x4c, 0x64, 0x53, 0x99, 0x64, 0x68, 0x75, 0x98, 0xa6, 0xbe, 0x83, 0x8e,
+	0xf4, 0x91, 0xfe, 0x04, 0x9b, 0x07, 0xb1, 0x1c, 0x9d, 0x0d, 0xb9, 0xe2, 0x4c, 0xfc, 0x98, 0x8b,
+	0x4c, 0x91, 0x37, 0xa1, 0x89, 0x85, 0x5a, 0x3d, 0x43, 0x68, 0x2e, 0x16, 0xec, 0x37, 0x0c, 0x17,
+	0x09, 0xcd, 0x45, 0x7b, 0xac, 0xda, 0x63, 0x86, 0xd0, 0xdc, 0x30, 0x8e, 0x46, 0xa6, 0x5a, 0x8f,
+	0x19, 0x42, 0xd7, 0xf1, 0x24, 0x12, 0x17, 0xb6, 0x44, 0x3c, 0xd3, 0x00, 0xb6, 0x6a, 0xf1, 0x6d,
+	0x9a, 0x3b, 0xd0, 0x62, 0xf2, 0x22, 0x18, 0x66, 0xbe, 0xd3, 0x73, 0xf7, 0x3c, 0x66, 0x29, 0x6c,
+	0xa4, 0x8c, 0xf3, 0x49, 0xa2, 0x45, 0x0d, 0x14, 0x55, 0x0c, 0x7a, 0x17, 0x9a, 0xd8, 0x55, 0x5d,
+	0x65, 0x65, 0xab, 0x8f, 0xf4, 0x67, 0x07, 0x3a, 0x47, 0xfc, 0x12, 0xd3, 0xc8, 0xc8, 0x63, 0x68,
+	0x87, 0x8a, 0x27, 0x63, 0x9e, 0x8e, 0x51, 0x69, 0xfd, 0xe1, 0xbb, 0xfd, 0x62, 0xca, 0xfd, 0x52,
+	0xad, 0x5f, 0xe8, 0x1c, 0x26, 0x2a, 0x9d, 0xb1, 0xd2, 0xe4, 0xde, 0xa7, 0xd0, 0xbd, 0x26, 0xd2,
+	0xf1, 0xce, 0xc4, 0xac, 0xe8, 0xea, 0x99, 0x98, 0xe9, 0xfa, 0xcf, 0x79, 0x9c, 0x9b, 0x5e, 0x79,
+	0xcc, 0x10, 0x9f, 0x34, 0x3e, 0x72, 0xe8, 0x3e, 0x90, 0x41, 0x2a, 0xb8, 0x12, 0x18, 0xe4, 0x48,
+	0x64, 0x19, 0x7f, 0x26, 0x56, 0x77, 0xdc, 0x74, 0xb1, 0x51, 0xeb, 0x22, 0xfd, 0x00, 0xc8, 0x50,
+	0xc4, 0x42, 0x09, 0x0b, 0xc6, 0x97, 0x78, 0xa0, 0x61, 0x11, 0xed, 0x66, 0x5d, 0xf2, 0x1e, 0x78,
+	0x1a, 0xcb, 0x18, 0x6c, 0xfd, 0xe1, 0x9d, 0xaa, 0x23, 0x25, 0xe8, 0x19, 0x2a, 0xd0, 0xa8, 0x70,
+	0x6a, 0xf1, 0x7f, 0x43, 0x09, 0x4b, 0x40, 0x53, 0x84, 0x72, 0xe7, 0x43, 0x95, 0x1b, 0x65, 0x43,
+	0xed, 0x17, 0xb5, 0xde, 0x36, 0x14, 0xcd, 0x60, 0xdb, 0x24, 0x7b, 0x10, 0x06, 0x5f, 0xa4, 0x32,
+	0x9f, 0xde, 0x26, 0xdf, 0x3e, 0xb4, 0x0b, 0x73, 0x9b, 0x33, 0xa9, 0x72, 0x2e, 0x24, 0xac, 0xd4,
+	0xa1, 0x3f, 0xc0, 0xb6, 0x49, 0xfb, 0x75, 0x82, 0xde, 0x9b, 0x0b, 0xda, 0xa9, 0x05, 0xf8, 0xce,
+	0x5a, 0xe8, 0x95, 0x3a, 0xd6, 0x96, 0xc6, 0x1f, 0x9e, 0x57, 0x0f, 0x72, 0xae, 0xbb, 0x3a, 0xae,
+	0xde, 0xc1, 0xcc, 0x77, 0x7b, 0xae, 0x8e, 0x8b, 0x04, 0x7d, 0x04, 0xad, 0x70, 0xf4, 0x5c, 0x4c,
+	0x38, 0x79, 0x1f, 0xd6, 0x30, 0x41, 0x91, 0xd9, 0x35, 0x79, 0x63, 0x0e, 0x14, 0xac, 0x90, 0xd3,
+	0xa1, 0x2d, 0x6c, 0x45, 0x42, 0x2d, 0x0c, 0x9d, 0xf9, 0xde, 0xbc, 0x1b, 0xe4, 0x33, 0x2b, 0xa6,
+	0x87, 0xe0, 0x9e, 0xb2, 0x40, 0xaf, 0x3f, 0x66, 0x50, 0x78, 0xb1, 0x94, 0xf6, 0xfd, 0xa5, 0xcc,
+	0x94, 0x6d, 0x13, 0x9e, 0x35, 0xef, 0x1b, 0x99, 0x2a, 0xec, 0x50, 0x97, 0xe1, 0x99, 0x7e, 0x0f,
+	0xde, 0xb1, 0x1c, 0x0b, 0xb2, 0x01, 0x8d, 0x60, 0x68, 0x7d, 0x34, 0x82, 0x21, 0x79, 0x07, 0xdd,
+	0xdb, 0xbe, 0x74, 0xab, 0x24, 0x4e, 0x59, 0xc0, 0x30, 0xf0, 0x7d, 0xe8, 0x06, 0xd9, 0x40, 0xca,
+	0x74, 0x1c, 0x25, 0x5c, 0xc9, 0x14, 0xbd, 0xb6, 0xd9, 0x75, 0x26, 0xdd, 0x87, 0x4d, 0xed, 0x3e,
+	0x54, 0x5c, 0x95, 0x90, 0xdc, 0x81, 0x96, 0xe6, 0x95, 0xe1, 0x2c, 0x85, 0x2b, 0xac, 0xf5, 0x8a,
+	0xd1, 0x22, 0x41, 0xbf, 0x36, 0x1e, 0x0e, 0xcf, 0x45, 0xa2, 0x6a, 0xd0, 0x40, 0x1a, 0x1d, 0x74,
+	0x99, 0x21, 0x08, 0x35, 0xa5, 0xd8, 0x9c, 0x37, 0xaa, 0x9c, 0x35, 0x97, 0xa1, 0x8c, 0xfe, 0xea,
+	0x00, 0x14, 0x09, 0xe5, 0x59, 0x69, 0xe2, 0xac, 0x36, 0x21, 0x1f, 0xd6, 0xae, 0xc3, 0x45, 0x9c,
+	0x94, 0x22, 0x56, 0xbb, 0x34, 0xf7, 0x0a, 0x58, 0xd8, 0x0d, 0xd8, 0xac, 0xf4, 0x0d, 0xdf, 0x8e,
+	0x49, 0xdf, 0x0f, 0xdd, 0x41, 0x9c, 0x67, 0x4a, 0xa4, 0x36, 0x23, 0x7d, 0x6d, 0x1b, 0x46, 0xd9,
+	0x9f, 0x8a, 0xb1, 0xbc, 0x45, 0xe4, 0x3e, 0x34, 0x75, 0xa6, 0x06, 0x9b, 0x8b, 0x65, 0x18, 0x21,
+	0x7d, 0x52, 0xed, 0xc8, 0x52, 0xe4, 0x15, 0x2f, 0x67, 0x63, 0xf1, 0xe5, 0x74, 0x17, 0x5e, 0x4e,
+	0xaf, 0x7a, 0x39, 0x43, 0xd8, 0x32, 0xb7, 0x86, 0x5e, 0x89, 0xdb, 0x2c, 0x6f, 0xf1, 0xd4, 0xb9,
+	0xb5, 0xa7, 0x2e, 0x84, 0x2d, 0x73, 0x2b, 0xfc, 0x97, 0x4e, 0x7f, 0x6f, 0xc0, 0x16, 0x13, 0x59,
+	0xf4, 0x42, 0x04, 0x49, 0xa6, 0xd2, 0x7c, 0xa4, 0x22, 0x99, 0x68, 0xfb, 0xaf, 0xe4, 0x53, 0xdb,
+	0x6d, 0x97, 0x19, 0xe2, 0x55, 0xc0, 0x44, 0x1e, 0xc0, 0xfa, 0xfc, 0x02, 0x2c, 0xaa, 0xd6, 0x55,
+	0xc8, 0x03, 0x58, 0x0b, 0x65, 0x9e, 0x8e, 0xca, 0xf5, 0xde, 0xa9, 0xb4, 0x4d, 0x66, 0x46, 0xcc,
+	0x0a, 0xb5, 0x1a, 0x94, 0x9a, 0x2f, 0x87, 0x12, 0x79, 0x3c, 0x07, 0x25, 0xbf, 0x85, 0x06, 0x6f,
+	0x55, 0x06, 0xd7, 0xc4, 0xec, 0xba, 0x36, 0xfd, 0xc5, 0x81, 0xff, 0xd7, 0x53, 0x78, 0xa5, 0xdd,
+	0x28, 0x27, 0xd2, 0x58, 0x3a, 0x11, 0x77, 0xd9, 0x44, 0xbc, 0x6a, 0x22, 0xd5, 0xab, 0xdd, 0xac,
+	0xbf, 0xda, 0x67, 0x70, 0x77, 0x61, 0x4c, 0x03, 0x39, 0x99, 0x6a, 0x3c, 0xbc, 0xc6, 0xb8, 0xf4,
+	0xad, 0x91, 0xa6, 0x76, 0x50, 0x1d, 0x66, 0x08, 0xfa, 0x31, 0x6c, 0x87, 0x42, 0xd5, 0x86, 0x54,
+	0xa0, 0xad, 0x07, 0xee, 0xb1, 0xb8, 0x58, 0x51, 0xbe, 0x16, 0xd1, 0xcf, 0xc0, 0x3f, 0x9d, 0x8e,
+	0xb9, 0x12, 0xb7, 0xb2, 0x3e, 0x80, 0xf6, 0x89, 0x9c, 0xca, 0x58, 0x3e, 0x9b, 0xdd, 0xb0, 0xf5,
+	0x3e, 0xac, 0x99, 0x2b, 0xd2, 0x7c, 0xe4, 0x3a, 0xac, 0x20, 0xe9, 0x1d, 0x0d, 0xe8, 0x11, 0x8f,
+	0x47, 0x79, 0xac, 0xd3, 0xd0, 0x3f, 0xba, 0xec, 0x60, 0xf3, 0xcf, 0xab, 0x5d, 0xe7, 0xaf, 0xab,
+	0x5d, 0xe7, 0xef, 0xab, 0x5d, 0xe7, 0xb7, 0x7f, 0x76, 0xff, 0xf7, 0xb4, 0x85, 0xdf, 0xf3, 0x47,
+	0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0xa3, 0xc6, 0x83, 0xfe, 0xaf, 0x0b, 0x00, 0x00,
 }
diff --git a/internal/private.proto b/internal/private.proto
index b530257ae..df004456f 100644
--- a/internal/private.proto
+++ b/internal/private.proto
@@ -12,7 +12,6 @@ message FrameMeta {
     int64 Min = 9;
     int64 Max = 10;
 	string TimeQuantum = 5;
-	//repeated Field Fields = 7;
 }
 
 message ImportResponse {
@@ -65,16 +64,16 @@ message DeleteFrameMessage {
     string Frame = 2;
 }
 
-message CreateFieldMessage {
+message CreateBSIGroupMessage {
     string Index = 1;
     string Frame = 2;
-    Field Field = 3;
+    BSIGroup BSIGroup = 3;
 }
 
-message DeleteFieldMessage {
+message DeleteBSIGroupMessage {
     string Index = 1;
     string Frame = 2;
-    string Field = 3;
+    string BSIGroup = 3;
 }
 
 message Frame {
@@ -126,7 +125,7 @@ message ClusterStatus {
     repeated Node Nodes = 3;
 }
 
-message Field {
+message BSIGroup {
     string Name = 1;
     string Type = 2;
     int64 Min = 3;
diff --git a/server.go b/server.go
index e7c566cbf..1e4f5a421 100644
--- a/server.go
+++ b/server.go
@@ -470,15 +470,15 @@ func (s *Server) ReceiveMessage(pb proto.Message) error {
 		if err := idx.DeleteFrame(obj.Frame); err != nil {
 			return err
 		}
-	case *internal.CreateFieldMessage:
+	case *internal.CreateBSIGroupMessage:
 		f := s.Holder.Frame(obj.Index, obj.Frame)
-		field := decodeField(obj.Field)
+		field := decodeBSIGroup(obj.BSIGroup)
 		if err := f.createBSIGroup(field); err != nil {
 			return err
 		}
-	case *internal.DeleteFieldMessage:
+	case *internal.DeleteBSIGroupMessage:
 		f := s.Holder.Frame(obj.Index, obj.Frame)
-		if err := f.DeleteField(obj.Field); err != nil {
+		if err := f.deleteBSIGroupAndView(obj.BSIGroup); err != nil {
 			return err
 		}
 	case *internal.CreateViewMessage:

From d80d3b6d5121d35b2f43a9e7896c57030e82d440 Mon Sep 17 00:00:00 2001
From: Travis Turner <travis@pilosa.com>
Date: Mon, 4 Jun 2018 17:25:57 -0500
Subject: [PATCH 8/9] rename cases of Field in view.go

---
 executor_test.go |  2 +-
 frame.go         | 12 ++++++------
 view.go          | 24 ++++++++++++------------
 3 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/executor_test.go b/executor_test.go
index 578ddc11b..4b75686a4 100644
--- a/executor_test.go
+++ b/executor_test.go
@@ -335,7 +335,7 @@ func TestExecutor_Execute_SetValue(t *testing.T) {
 
 		t.Run("ErrInvalidFieldValueType", func(t *testing.T) {
 			e := test.NewExecutor(hldr.Holder, test.NewCluster(1))
-			if _, err := e.Execute(context.Background(), "i", test.MustParse(`SetValue(col=10, 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 != pilosa.ErrInvalidBSIGroupValueType {
 				t.Fatalf("unexpected error: %s", err)
 			}
 		})
diff --git a/frame.go b/frame.go
index 65d98937c..15dcc03f4 100644
--- a/frame.go
+++ b/frame.go
@@ -718,7 +718,7 @@ func (f *Frame) Value(columnID uint64, name string) (value int64, exists bool, e
 		return 0, false, nil
 	}
 
-	v, exists, err := view.FieldValue(columnID, field.BitDepth())
+	v, exists, err := view.value(columnID, field.BitDepth())
 	if err != nil {
 		return 0, false, err
 	} else if !exists {
@@ -764,7 +764,7 @@ func (f *Frame) Sum(filter *Row, name string) (sum, count int64, err error) {
 		return 0, 0, nil
 	}
 
-	vsum, vcount, err := view.FieldSum(filter, field.BitDepth())
+	vsum, vcount, err := view.sum(filter, field.BitDepth())
 	if err != nil {
 		return 0, 0, err
 	}
@@ -784,7 +784,7 @@ func (f *Frame) Min(filter *Row, name string) (min, count int64, err error) {
 		return 0, 0, nil
 	}
 
-	vmin, vcount, err := view.FieldMin(filter, bsig.BitDepth())
+	vmin, vcount, err := view.min(filter, bsig.BitDepth())
 	if err != nil {
 		return 0, 0, err
 	}
@@ -804,7 +804,7 @@ func (f *Frame) Max(filter *Row, name string) (max, count int64, err error) {
 		return 0, 0, nil
 	}
 
-	vmax, vcount, err := view.FieldMax(filter, field.BitDepth())
+	vmax, vcount, err := view.max(filter, field.BitDepth())
 	if err != nil {
 		return 0, 0, err
 	}
@@ -831,7 +831,7 @@ func (f *Frame) Range(name string, op pql.Token, predicate int64) (*Row, error)
 		return NewRow(), nil
 	}
 
-	return view.FieldRange(op, field.BitDepth(), baseValue)
+	return view.rangeOp(op, field.BitDepth(), baseValue)
 }
 
 func (f *Frame) RangeBetween(name string, predicateMin, predicateMax int64) (*Row, error) {
@@ -854,7 +854,7 @@ func (f *Frame) RangeBetween(name string, predicateMin, predicateMax int64) (*Ro
 		return NewRow(), nil
 	}
 
-	return view.FieldRangeBetween(field.BitDepth(), baseValueMin, baseValueMax)
+	return view.rangeBetween(field.BitDepth(), baseValueMin, baseValueMax)
 }
 
 // Import bulk imports data.
diff --git a/view.go b/view.go
index 994a54579..31bf9a470 100644
--- a/view.go
+++ b/view.go
@@ -323,8 +323,8 @@ func (v *View) ClearBit(rowID, columnID uint64) (changed bool, err error) {
 	return frag.ClearBit(rowID, columnID)
 }
 
-// FieldValue uses a column of bits to read a multi-bit value.
-func (v *View) FieldValue(columnID uint64, bitDepth uint) (value uint64, exists bool, err error) {
+// value uses a column of bits to read a multi-bit value.
+func (v *View) value(columnID uint64, bitDepth uint) (value uint64, exists bool, err error) {
 	slice := columnID / SliceWidth
 	frag, err := v.CreateFragmentIfNotExists(slice)
 	if err != nil {
@@ -343,8 +343,8 @@ func (v *View) setValue(columnID uint64, bitDepth uint, value uint64) (changed b
 	return frag.SetValue(columnID, bitDepth, value)
 }
 
-// FieldSum returns the sum & count of a field.
-func (v *View) FieldSum(filter *Row, bitDepth uint) (sum, count uint64, err error) {
+// sum returns the sum & count of a field.
+func (v *View) sum(filter *Row, bitDepth uint) (sum, count uint64, err error) {
 	for _, f := range v.Fragments() {
 		fsum, fcount, err := f.FieldSum(filter, bitDepth)
 		if err != nil {
@@ -356,8 +356,8 @@ func (v *View) FieldSum(filter *Row, bitDepth uint) (sum, count uint64, err erro
 	return sum, count, nil
 }
 
-// FieldMin returns the min and count of a field.
-func (v *View) FieldMin(filter *Row, bitDepth uint) (min, count uint64, err error) {
+// min returns the min and count of a field.
+func (v *View) min(filter *Row, bitDepth uint) (min, count uint64, err error) {
 	var minHasValue bool
 	for _, f := range v.Fragments() {
 		fmin, fcount, err := f.FieldMin(filter, bitDepth)
@@ -384,8 +384,8 @@ func (v *View) FieldMin(filter *Row, bitDepth uint) (min, count uint64, err erro
 	return min, count, nil
 }
 
-// FieldMax returns the max and count of a field.
-func (v *View) FieldMax(filter *Row, bitDepth uint) (max, count uint64, err error) {
+// max returns the max and count of a field.
+func (v *View) max(filter *Row, bitDepth uint) (max, count uint64, err error) {
 	for _, f := range v.Fragments() {
 		fmax, fcount, err := f.FieldMax(filter, bitDepth)
 		if err != nil {
@@ -399,8 +399,8 @@ func (v *View) FieldMax(filter *Row, bitDepth uint) (max, count uint64, err erro
 	return max, count, nil
 }
 
-// FieldRange returns rows with a field value encoding matching the predicate.
-func (v *View) FieldRange(op pql.Token, bitDepth uint, predicate uint64) (*Row, error) {
+// rangeOp returns rows with a field value encoding matching the predicate.
+func (v *View) rangeOp(op pql.Token, bitDepth uint, predicate uint64) (*Row, error) {
 	r := NewRow()
 	for _, frag := range v.Fragments() {
 		other, err := frag.FieldRange(op, bitDepth, predicate)
@@ -412,9 +412,9 @@ func (v *View) FieldRange(op pql.Token, bitDepth uint, predicate uint64) (*Row,
 	return r, nil
 }
 
-// FieldRangeBetween returns bitmaps with a field value encoding matching any
+// rangeBetween returns bitmaps with a field value encoding matching any
 // value between predicateMin and predicateMax.
-func (v *View) FieldRangeBetween(bitDepth uint, predicateMin, predicateMax uint64) (*Row, error) {
+func (v *View) rangeBetween(bitDepth uint, predicateMin, predicateMax uint64) (*Row, error) {
 	r := NewRow()
 	for _, frag := range v.Fragments() {
 		other, err := frag.FieldRangeBetween(bitDepth, predicateMin, predicateMax)

From 51a42d3e359b5dc03102d83c25c20252f736f0a9 Mon Sep 17 00:00:00 2001
From: Travis Turner <travis@pilosa.com>
Date: Mon, 4 Jun 2018 17:40:25 -0500
Subject: [PATCH 9/9] rename test names

---
 frame_test.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/frame_test.go b/frame_test.go
index aeae2b7ba..d3e274fe9 100644
--- a/frame_test.go
+++ b/frame_test.go
@@ -147,7 +147,7 @@ func TestFrame_SetValue(t *testing.T) {
 		}
 	})
 
-	t.Run("ErrFieldNotFound", func(t *testing.T) {
+	t.Run("ErrBSIGroupNotFound", func(t *testing.T) {
 		idx := test.MustOpenIndex()
 		defer idx.Close()
 
@@ -164,7 +164,7 @@ func TestFrame_SetValue(t *testing.T) {
 		}
 	})
 
-	t.Run("ErrFieldValueTooLow", func(t *testing.T) {
+	t.Run("ErrBSIGroupValueTooLow", func(t *testing.T) {
 		idx := test.MustOpenIndex()
 		defer idx.Close()
 
@@ -183,7 +183,7 @@ func TestFrame_SetValue(t *testing.T) {
 		}
 	})
 
-	t.Run("ErrFieldValueTooHigh", func(t *testing.T) {
+	t.Run("ErrBSIGroupValueTooHigh", func(t *testing.T) {
 		idx := test.MustOpenIndex()
 		defer idx.Close()