From d80d3b6d5121d35b2f43a9e7896c57030e82d440 Mon Sep 17 00:00:00 2001 From: Travis Turner Date: Mon, 4 Jun 2018 17:25:57 -0500 Subject: [PATCH] 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)