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

rename fragment.SetFieldValue() to fragment.SetValue(). Still exported for tests

Browse source
This commit is contained in:
Travis Turner 2018-06-01 22:25:26 -05:00
parent 17c8944685
commit dd6b80f90d
No known key found for this signature in database
GPG key ID: 7F08008DFD9314C9
5 changed files with 50 additions and 100 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
fragment.go
View file

@ -510,8 +510,8 @@ func (f *Fragment) FieldValue(columnID uint64, bitDepth uint) (value uint64, exi
return value, true, nil
}
// SetFieldValue uses a column of bits to set a multi-bit value.
func (f *Fragment) SetFieldValue(columnID uint64, bitDepth uint, value uint64) (changed bool, err error) {
// SetValue uses a column of bits to set a multi-bit value.
func (f *Fragment) SetValue(columnID uint64, bitDepth uint, value uint64) (changed bool, err error) {
f.mu.Lock()
defer f.mu.Unlock()
@ -541,8 +541,8 @@ func (f *Fragment) SetFieldValue(columnID uint64, bitDepth uint, value uint64) (
return changed, nil
}
// importSetFieldValue is a more efficient SetFieldValue just for imports.
func (f *Fragment) importSetFieldValue(columnID uint64, bitDepth uint, value uint64) (changed bool, err error) {
// importSetValue is a more efficient SetValue just for imports.
func (f *Fragment) importSetValue(columnID uint64, bitDepth uint, value uint64) (changed bool, err error) {
for i := uint(0); i < bitDepth; i++ {
if value&(1<<i) != 0 {
@ -1408,7 +1408,7 @@ func (f *Fragment) ImportValue(columnIDs, values []uint64, bitDepth uint) error
for i := range columnIDs {
columnID, value := columnIDs[i], values[i]
_, err := f.importSetFieldValue(columnID, bitDepth, value)
_, err := f.importSetValue(columnID, bitDepth, value)
if err != nil {
return errors.Wrap(err, "setting")
}

88
fragment_test.go
View file

@ -97,13 +97,13 @@ func TestFragment_ClearBit(t *testing.T) {
}
// Ensure a fragment can set & read a field value.
func TestFragment_SetFieldValue(t *testing.T) {
func TestFragment_SetValue(t *testing.T) {
t.Run("OK", func(t *testing.T) {
f := test.MustOpenFragment("i", "f", pilosa.ViewStandard, 0, "")
defer f.Close()
// Set value.
if changed, err := f.SetFieldValue(100, 16, 3829); err != nil {
if changed, err := f.SetValue(100, 16, 3829); err != nil {
t.Fatal(err)
} else if !changed {
t.Fatal("expected change")
@ -119,7 +119,7 @@ func TestFragment_SetFieldValue(t *testing.T) {
}
// Setting value should return no change.
if changed, err := f.SetFieldValue(100, 16, 3829); err != nil {
if changed, err := f.SetValue(100, 16, 3829); err != nil {
t.Fatal(err)
} else if changed {
t.Fatal("expected no change")
@ -131,14 +131,14 @@ func TestFragment_SetFieldValue(t *testing.T) {
defer f.Close()
// Set value.
if changed, err := f.SetFieldValue(100, 16, 3829); err != nil {
if changed, err := f.SetValue(100, 16, 3829); err != nil {
t.Fatal(err)
} else if !changed {
t.Fatal("expected change")
}
// Overwriting value should overwrite all bits.
if changed, err := f.SetFieldValue(100, 16, 2028); err != nil {
if changed, err := f.SetValue(100, 16, 2028); err != nil {
t.Fatal(err)
} else if !changed {
t.Fatal("expected change")
@ -159,7 +159,7 @@ func TestFragment_SetFieldValue(t *testing.T) {
defer f.Close()
// Set value.
if changed, err := f.SetFieldValue(100, 10, 20); err != nil {
if changed, err := f.SetValue(100, 10, 20); err != nil {
t.Fatal(err)
} else if !changed {
t.Fatal("expected change")
@ -195,7 +195,7 @@ func TestFragment_SetFieldValue(t *testing.T) {
m[columnID] = int64(value)
if _, err := f.SetFieldValue(columnID, bitDepth, value); err != nil {
if _, err := f.SetValue(columnID, bitDepth, value); err != nil {
t.Fatal(err)
}
}
@ -227,13 +227,13 @@ func TestFragment_FieldSum(t *testing.T) {
defer f.Close()
// Set values.
if _, err := f.SetFieldValue(1000, bitDepth, 382); err != nil {
if _, err := f.SetValue(1000, bitDepth, 382); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(2000, bitDepth, 300); err != nil {
} else if _, err := f.SetValue(2000, bitDepth, 300); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(3000, bitDepth, 2818); err != nil {
} else if _, err := f.SetValue(3000, bitDepth, 2818); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(4000, bitDepth, 300); err != nil {
} else if _, err := f.SetValue(4000, bitDepth, 300); err != nil {
t.Fatal(err)
}
@ -266,19 +266,19 @@ func TestFragment_FieldMinMax(t *testing.T) {
defer f.Close()
// Set values.
if _, err := f.SetFieldValue(1000, bitDepth, 382); err != nil {
if _, err := f.SetValue(1000, bitDepth, 382); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(2000, bitDepth, 300); err != nil {
} else if _, err := f.SetValue(2000, bitDepth, 300); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(3000, bitDepth, 2818); err != nil {
} else if _, err := f.SetValue(3000, bitDepth, 2818); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(4000, bitDepth, 300); err != nil {
} else if _, err := f.SetValue(4000, bitDepth, 300); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(5000, bitDepth, 2818); err != nil {
} else if _, err := f.SetValue(5000, bitDepth, 2818); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(6000, bitDepth, 2817); err != nil {
} else if _, err := f.SetValue(6000, bitDepth, 2817); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(7000, bitDepth, 0); err != nil {
} else if _, err := f.SetValue(7000, bitDepth, 0); err != nil {
t.Fatal(err)
}
@ -340,13 +340,13 @@ func TestFragment_FieldRange(t *testing.T) {
defer f.Close()
// Set values.
if _, err := f.SetFieldValue(1000, bitDepth, 382); err != nil {
if _, err := f.SetValue(1000, bitDepth, 382); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(2000, bitDepth, 300); err != nil {
} else if _, err := f.SetValue(2000, bitDepth, 300); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(3000, bitDepth, 2818); err != nil {
} else if _, err := f.SetValue(3000, bitDepth, 2818); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(4000, bitDepth, 300); err != nil {
} else if _, err := f.SetValue(4000, bitDepth, 300); err != nil {
t.Fatal(err)
}
@ -363,13 +363,13 @@ func TestFragment_FieldRange(t *testing.T) {
defer f.Close()
// Set values.
if _, err := f.SetFieldValue(1000, bitDepth, 382); err != nil {
if _, err := f.SetValue(1000, bitDepth, 382); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(2000, bitDepth, 300); err != nil {
} else if _, err := f.SetValue(2000, bitDepth, 300); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(3000, bitDepth, 2818); err != nil {
} else if _, err := f.SetValue(3000, bitDepth, 2818); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(4000, bitDepth, 300); err != nil {
} else if _, err := f.SetValue(4000, bitDepth, 300); err != nil {
t.Fatal(err)
}
@ -386,17 +386,17 @@ func TestFragment_FieldRange(t *testing.T) {
defer f.Close()
// Set values.
if _, err := f.SetFieldValue(1000, bitDepth, 382); err != nil {
if _, err := f.SetValue(1000, bitDepth, 382); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(2000, bitDepth, 300); err != nil {
} else if _, err := f.SetValue(2000, bitDepth, 300); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(3000, bitDepth, 2817); err != nil {
} else if _, err := f.SetValue(3000, bitDepth, 2817); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(4000, bitDepth, 301); err != nil {
} else if _, err := f.SetValue(4000, bitDepth, 301); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(5000, bitDepth, 1); err != nil {
} else if _, err := f.SetValue(5000, bitDepth, 1); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(6000, bitDepth, 0); err != nil {
} else if _, err := f.SetValue(6000, bitDepth, 0); err != nil {
t.Fatal(err)
}
@ -434,17 +434,17 @@ func TestFragment_FieldRange(t *testing.T) {
defer f.Close()
// Set values.
if _, err := f.SetFieldValue(1000, bitDepth, 382); err != nil {
if _, err := f.SetValue(1000, bitDepth, 382); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(2000, bitDepth, 300); err != nil {
} else if _, err := f.SetValue(2000, bitDepth, 300); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(3000, bitDepth, 2817); err != nil {
} else if _, err := f.SetValue(3000, bitDepth, 2817); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(4000, bitDepth, 301); err != nil {
} else if _, err := f.SetValue(4000, bitDepth, 301); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(5000, bitDepth, 1); err != nil {
} else if _, err := f.SetValue(5000, bitDepth, 1); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(6000, bitDepth, 0); err != nil {
} else if _, err := f.SetValue(6000, bitDepth, 0); err != nil {
t.Fatal(err)
}
@ -482,17 +482,17 @@ func TestFragment_FieldRange(t *testing.T) {
defer f.Close()
// Set values.
if _, err := f.SetFieldValue(1000, bitDepth, 382); err != nil {
if _, err := f.SetValue(1000, bitDepth, 382); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(2000, bitDepth, 300); err != nil {
} else if _, err := f.SetValue(2000, bitDepth, 300); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(3000, bitDepth, 2817); err != nil {
} else if _, err := f.SetValue(3000, bitDepth, 2817); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(4000, bitDepth, 301); err != nil {
} else if _, err := f.SetValue(4000, bitDepth, 301); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(5000, bitDepth, 1); err != nil {
} else if _, err := f.SetValue(5000, bitDepth, 1); err != nil {
t.Fatal(err)
} else if _, err := f.SetFieldValue(6000, bitDepth, 0); err != nil {
} else if _, err := f.SetValue(6000, bitDepth, 0); err != nil {
t.Fatal(err)
}

25
test/cluster.go
View file

@ -150,31 +150,6 @@ func (t *TestCluster) SetBit(index, frame, view string, rowID, colID uint64, x *
return nil
}
// TODO: remove `name` from this function signature
func (t *TestCluster) SetFieldValue(index, frame string, columnID uint64, name string, value int64) error {
// Determine which node should receive the SetFieldValue.
c0 := t.Clusters[0] // use the first node's cluster to determine slice location.
slice := columnID / pilosa.SliceWidth
nodes := c0.SliceNodes(index, slice)
for _, node := range nodes {
c := t.clusterByID(node.ID)
if c == nil {
continue
}
f := c.Holder.Frame(index, frame)
if f == nil {
return fmt.Errorf("index/frame does not exist: %s/%s", index, frame)
}
_, err := f.SetValue(columnID, value)
if err != nil {
return err
}
}
return nil
}
func (t *TestCluster) clusterByID(id string) *pilosa.Cluster {
for _, c := range t.Clusters {
if c.Node.ID == id {

25
utils_test.go
View file

@ -141,31 +141,6 @@ func (t *ClusterCluster) SetBit(index, frame, view string, rowID, colID uint64,
return nil
}
// TODO: remove `name` from this function signature
func (t *ClusterCluster) SetFieldValue(index, frame string, columnID uint64, name string, value int64) error {
// Determine which node should receive the SetFieldValue.
c0 := t.Clusters[0] // use the first node's cluster to determine slice location.
slice := columnID / SliceWidth
nodes := c0.SliceNodes(index, slice)
for _, node := range nodes {
c := t.clusterByID(node.ID)
if c == nil {
continue
}
f := c.Holder.Frame(index, frame)
if f == nil {
return fmt.Errorf("index/frame does not exist: %s/%s", index, frame)
}
_, err := f.SetValue(columnID, value)
if err != nil {
return err
}
}
return nil
}
func (t *ClusterCluster) clusterByID(id string) *Cluster {
for _, c := range t.Clusters {
if c.Node.ID == id {

2
view.go
View file

@ -340,7 +340,7 @@ func (v *View) setValue(columnID uint64, bitDepth uint, value uint64) (changed b
if err != nil {
return changed, err
}
return frag.SetFieldValue(columnID, bitDepth, value)
return frag.SetValue(columnID, bitDepth, value)
}
// FieldSum returns the sum & count of a field.