scriptoriumadmin/featurebase
1
0
Fork 0
mirror of https://github.com/featurebasedb/featurebase.git synced 2026-10-10 21:07:53 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

rename cases of Field in view.go

Browse source
This commit is contained in:
Travis Turner 2018-06-04 17:25:57 -05:00
parent a6ae39d0b0
commit d80d3b6d51
No known key found for this signature in database
GPG key ID: 7F08008DFD9314C9
3 changed files with 19 additions and 19 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
executor_test.go
View file

@ -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)
}
})

12
frame.go
View file

@ -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.

24
view.go
View file

@ -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)