From 552358743587bee08c38cab0529c0fe340732544 Mon Sep 17 00:00:00 2001 From: Jaden Weiss Date: Wed, 24 Jun 2020 14:18:19 -0400 Subject: [PATCH] pilosa: remove unused field code --- api_test.go | 58 +---------------- field.go | 155 -------------------------------------------- http/client_test.go | 109 ++++++++----------------------- view.go | 56 ---------------- 4 files changed, 31 insertions(+), 347 deletions(-) diff --git a/api_test.go b/api_test.go index 02e8a182f..3942a7337 100644 --- a/api_test.go +++ b/api_test.go @@ -361,7 +361,7 @@ func TestAPI_ImportValue(t *testing.T) { if err != nil { t.Fatalf("creating index: %v", err) } - fld, err := m1.API.CreateField(ctx, index, field, pilosa.OptFieldTypeDecimal(1)) + _, err = m1.API.CreateField(ctx, index, field, pilosa.OptFieldTypeDecimal(1)) if err != nil { t.Fatalf("creating field: %v", err) } @@ -386,66 +386,14 @@ func TestAPI_ImportValue(t *testing.T) { t.Fatal(err) } - pql := fmt.Sprintf("Row(%s>6)", field) + query := fmt.Sprintf("Row(%s>6)", field) // Query node0. - if res, err := m0.API.Query(ctx, &pilosa.QueryRequest{Index: index, Query: pql}); err != nil { + if res, err := m0.API.Query(ctx, &pilosa.QueryRequest{Index: index, Query: query}); err != nil { t.Fatal(err) } else if ids := res.Results[0].(*pilosa.Row).Columns(); !reflect.DeepEqual(ids, colIDs[6:]) { t.Fatalf("unexpected column keys: %+v", ids) } - - sum, count, err := fld.FloatSum(nil, field) - if err != nil { - t.Fatalf("getting floatsum: %v", err) - } else if sum != 0.1+1.1+2.1+3.1+4.1+5.1+6.1+7.1+8.1+9.1 { - t.Fatalf("unexpected sum: %f", sum) - } else if count != 10 { - t.Fatalf("unexpected count: %d", count) - } - - min, count, err := fld.FloatMin(nil, field) - if err != nil { - t.Fatalf("getting floatmin: %v", err) - } else if min != 0.1 { - t.Fatalf("unexpected min: %f", min) - } else if count != 1 { - t.Fatalf("unexpected count: %d", count) - } - - max, count, err := fld.FloatMax(nil, field) - if err != nil { - t.Fatalf("getting floatmax: %v", err) - } else if max != 9.1 { - t.Fatalf("unexpected max: %f", max) - } else if count != 1 { - t.Fatalf("unexpected count: %d", count) - } - - val, exists, err := fld.FloatValue(1) - if err != nil { - t.Fatalf("unepxected err getting floatvalue") - } else if !exists { - t.Fatalf("column 1 should exist") - } else if val != 1.1 { - t.Fatalf("unexpected floatvalue %f", val) - } - - changed, err := fld.SetFloatValue(11, 11.1) - if err != nil { - t.Fatalf("setting float value: %v", err) - } else if !changed { - t.Fatalf("expected change") - } - - val, exists, err = fld.FloatValue(11) - if err != nil { - t.Fatalf("getting float val: %v", err) - } else if !exists { - t.Fatalf("should exist") - } else if val != 11.1 { - t.Fatalf("unexpected val: %f", 11.1) - } }) t.Run("ValDecimalFieldNegativeScale", func(t *testing.T) { diff --git a/field.go b/field.go index 34352655d..b746e1800 100644 --- a/field.go +++ b/field.go @@ -1376,37 +1376,6 @@ func (f *Field) StringValue(columnID uint64) (value string, exists bool, err err return value, exists, err } -// FloatValue reads an integer field value for a column, and converts -// it to a float based on the configured scale. -func (f *Field) FloatValue(columnID uint64) (value float64, exists bool, err error) { - bsig := f.bsiGroup(f.name) - if bsig == nil { - return 0, false, ErrBSIGroupNotFound - } - - val, exists, err := f.Value(columnID) - if exists { - value = float64(val) / math.Pow10(int(bsig.Scale)) - } - return value, exists, err -} - -// DecimalValue reads a decimal field value for a column, and converts -// it to a pql.Decimal based on the configured scale. -func (f *Field) DecimalValue(columnID uint64) (value pql.Decimal, exists bool, err error) { - bsig := f.bsiGroup(f.name) - if bsig == nil { - return value, false, ErrBSIGroupNotFound - } - - val, exists, err := f.Value(columnID) - if exists { - value.Value = val - value.Scale = bsig.Scale - } - return value, exists, err -} - // Value reads a field value for a column. func (f *Field) Value(columnID uint64) (value int64, exists bool, err error) { bsig := f.bsiGroup(f.name) @@ -1429,18 +1398,6 @@ func (f *Field) Value(columnID uint64) (value int64, exists bool, err error) { return int64(v) + bsig.Base, true, nil } -// SetFloatValue takes a floating point value, and converts it to an -// integer based on the field's configured scale, before setting that -// integer via SetValue. -func (f *Field) SetFloatValue(columnID uint64, value float64) (changed bool, err error) { - bsig := f.bsiGroup(f.name) - if bsig == nil { - return false, ErrBSIGroupNotFound - } - val := int64(float64(value) * math.Pow10(int(bsig.Scale))) - return f.SetValue(columnID, val) -} - // SetValue sets a field value for a column. func (f *Field) SetValue(columnID uint64, value int64) (changed bool, err error) { // Fetch bsiGroup & validate min/max. @@ -1506,98 +1463,6 @@ func (f *Field) ClearValue(columnID uint64) (changed bool, err error) { return false, nil } -// FloatSum performs a Sum query and converts the result to a float -// based on the field's configured scale. -func (f *Field) FloatSum(filter *Row, name string) (sum float64, count int64, err error) { - bsig := f.bsiGroup(f.name) - if bsig == nil { - return 0, 0, ErrBSIGroupNotFound - } - - sumI, count, err := f.Sum(filter, name) - if err == nil { - sum = float64(sumI) / math.Pow10(int(bsig.Scale)) - } - return sum, count, err - -} - -// Sum returns the sum and count for a field. -// An optional filtering row can be provided. -func (f *Field) Sum(filter *Row, name string) (sum, count int64, err error) { - bsig := f.bsiGroup(name) - if bsig == nil { - return 0, 0, ErrBSIGroupNotFound - } - - view := f.view(viewBSIGroupPrefix + name) - if view == nil { - return 0, 0, nil - } - - vsum, vcount, err := view.sum(filter, bsig.BitDepth) - if err != nil { - return 0, 0, err - } - return int64(vsum) + (int64(vcount) * bsig.Base), int64(vcount), nil -} - -// FloatMin performs a Min query and converts the result to a float -// based on the field's configured scale. -// TODO: this and Min are probably worthless -func (f *Field) FloatMin(filter *Row, name string) (min float64, count int64, err error) { - bsig := f.bsiGroup(f.name) - if bsig == nil { - return 0, 0, ErrBSIGroupNotFound - } - - minI, count, err := f.Min(filter, name) - if err == nil { - min = float64(minI) / math.Pow10(int(bsig.Scale)) - } - return min, count, err -} - -// Min returns the min for a field. -// An optional filtering row can be provided. -func (f *Field) Min(filter *Row, name string) (min, count int64, err error) { - bsig := f.bsiGroup(name) - if bsig == nil { - return 0, 0, ErrBSIGroupNotFound - } - - view := f.view(viewBSIGroupPrefix + name) - if view == nil { - return 0, 0, nil - } - - vmin, vcount, err := view.min(filter, bsig.BitDepth) - if err != nil { - return 0, 0, err - } - return int64(vmin) + bsig.Base, int64(vcount), nil -} - -// FloatMax performs a max query and converts the result to a float -// based on the field's configured scale. -// -// TODO, this isn't really used, because it's kind of useless. It will -// only get the max among shards on this node, but all query execution -// already happens at the shard level and bypasses this entirely -// calling fragment.max instead. -func (f *Field) FloatMax(filter *Row, name string) (max float64, count int64, err error) { - bsig := f.bsiGroup(f.name) - if bsig == nil { - return 0, 0, ErrBSIGroupNotFound - } - - maxI, count, err := f.Max(filter, name) - if err == nil { - max = float64(maxI) / math.Pow10(int(bsig.Scale)) - } - return max, count, err -} - func (f *Field) MaxForShard(shard uint64, filter *Row) (ValCount, error) { bsig := f.bsiGroup(f.name) if bsig == nil { @@ -1667,26 +1532,6 @@ func (f *Field) MinForShard(shard uint64, filter *Row) (ValCount, error) { return valCount, nil } -// Max returns the max for a field. -// An optional filtering row can be provided. -func (f *Field) Max(filter *Row, name string) (max, count int64, err error) { - bsig := f.bsiGroup(name) - if bsig == nil { - return 0, 0, ErrBSIGroupNotFound - } - - view := f.view(viewBSIGroupPrefix + name) - if view == nil { - return 0, 0, nil - } - - vmax, vcount, err := view.max(filter, bsig.BitDepth) - if err != nil { - return 0, 0, err - } - return int64(vmax) + bsig.Base, int64(vcount), nil -} - // Range performs a conditional operation on Field. func (f *Field) Range(name string, op pql.Token, predicate int64) (*Row, error) { // Retrieve and validate bsiGroup. diff --git a/http/client_test.go b/http/client_test.go index fb5568658..ff543def5 100644 --- a/http/client_test.go +++ b/http/client_test.go @@ -777,7 +777,7 @@ func TestClient_ImportKeys(t *testing.T) { // Load bitmap into cache to ensure cache gets updated. index := hldr.MustCreateIndexIfNotExists("i", pilosa.IndexOptions{Keys: true}) - field, err := index.CreateFieldIfNotExists(fldName, pilosa.OptFieldTypeInt(-100, 100)) + _, err := index.CreateFieldIfNotExists(fldName, pilosa.OptFieldTypeInt(-100, 100)) if err != nil { t.Fatal(err) } @@ -792,15 +792,6 @@ func TestClient_ImportKeys(t *testing.T) { t.Fatal(err) } - // Verify Sum. - sum, cnt, err := field.Sum(nil, fldName) - if err != nil { - t.Fatal(err) - } - if sum != 50 || cnt != 3 { - t.Fatalf("unexpected values: got sum=%v, count=%v; expected sum=50, cnt=3", sum, cnt) - } - // Verify range. queryRequest := &pilosa.QueryRequest{ Query: fmt.Sprintf(`Row(%s>10)`, fldName), @@ -823,15 +814,6 @@ func TestClient_ImportKeys(t *testing.T) { t.Fatal(err) } - // Verify Sum. - sum, cnt, err = field.Sum(nil, fldName) - if err != nil { - t.Fatal(err) - } - if sum != 30 || cnt != 2 { - t.Fatalf("unexpected values: got sum=%v, count=%v; expected sum=30, cnt=2", sum, cnt) - } - // Verify Range. queryRequest = &pilosa.QueryRequest{ Query: fmt.Sprintf(`Row(%s>10)`, fldName), @@ -928,7 +910,7 @@ func TestClient_ImportValue(t *testing.T) { // Load bitmap into cache to ensure cache gets updated. index := hldr.MustCreateIndexIfNotExists("i", pilosa.IndexOptions{}) - field, err := index.CreateFieldIfNotExists(fldName, pilosa.OptFieldTypeInt(-100, 100)) + _, err := index.CreateFieldIfNotExists(fldName, pilosa.OptFieldTypeInt(-100, 100)) if err != nil { t.Fatal(err) } @@ -944,43 +926,21 @@ func TestClient_ImportValue(t *testing.T) { } // Verify Sum. - sum, cnt, err := field.Sum(nil, fldName) - if err != nil { + if resp, err := c.Query(context.Background(), "i", &pilosa.QueryRequest{Query: `Sum(field=f)`}); err != nil { t.Fatal(err) - } - if sum != 50 || cnt != 3 { - t.Fatalf("unexpected values: got sum=%v, count=%v; expected sum=50, cnt=3", sum, cnt) - } - - // Verify Min. - min, cnt, err := field.Min(nil, fldName) - if err != nil { - t.Fatal(err) - } - if min != -10 || cnt != 1 { - t.Fatalf("unexpected values: got min=%v, count=%v; expected min=-10, cnt=1", min, cnt) - } - - // Verify Min with Filter. - filter, err := field.Range(fldName, pql.GT, 40) - if err != nil { - t.Fatal(err) - } - min, cnt, err = field.Min(filter, fldName) - if err != nil { - t.Fatal(err) - } - if min != 0 || cnt != 0 { - t.Fatalf("unexpected values: got min=%v, count=%v; expected min=0, cnt=0", min, cnt) + } else if vc, ok := resp.Results[0].(pilosa.ValCount); !ok { + t.Fatalf("expected ValCount; got %T", resp.Results[0]) + } else if vc.Val != 50 || vc.Count != 3 { + t.Fatalf("unexpected values: got sum=%v, count=%v; expected sum=50, cnt=3", vc.Val, vc.Count) } // Verify Max. - max, cnt, err := field.Max(nil, fldName) - if err != nil { + if resp, err := c.Query(context.Background(), "i", &pilosa.QueryRequest{Query: `Max(field=f)`}); err != nil { t.Fatal(err) - } - if max != 40 || cnt != 1 { - t.Fatalf("unexpected values: got max=%v, count=%v; expected max=40, cnt=1", max, cnt) + } else if vc, ok := resp.Results[0].(pilosa.ValCount); !ok { + t.Fatalf("expected ValCount; got %T", resp.Results[0]) + } else if vc.Val != 40 || vc.Count != 1 { + t.Fatalf("unexpected values: got max=%v, count=%v; expected max=40, cnt=1", vc.Val, vc.Count) } // Send import request. @@ -992,34 +952,21 @@ func TestClient_ImportValue(t *testing.T) { } // Verify Sum. - sum, cnt, err = field.Sum(nil, fldName) - if err != nil { + if resp, err := c.Query(context.Background(), "i", &pilosa.QueryRequest{Query: `Sum(field=f)`}); err != nil { t.Fatal(err) - } - if sum != 20 || cnt != 1 { - t.Fatalf("unexpected values: got sum=%v, count=%v; expected sum=20, cnt=1", sum, cnt) - } - - // Verify Min with Filter. - filter, err = field.Range(fldName, pql.GT, 40) - if err != nil { - t.Fatal(err) - } - min, cnt, err = field.Min(filter, fldName) - if err != nil { - t.Fatal(err) - } - if min != 0 || cnt != 0 { - t.Fatalf("unexpected values: got min=%v, count=%v; expected min=0, cnt=0", min, cnt) + } else if vc, ok := resp.Results[0].(pilosa.ValCount); !ok { + t.Fatalf("expected ValCount; got %T", resp.Results[0]) + } else if vc.Val != 20 || vc.Count != 1 { + t.Fatalf("unexpected values: got sum=%v, count=%v; expected sum=20, cnt=1", vc.Val, vc.Count) } // Verify Max. - max, cnt, err = field.Max(nil, fldName) - if err != nil { + if resp, err := c.Query(context.Background(), "i", &pilosa.QueryRequest{Query: `Max(field=f)`}); err != nil { t.Fatal(err) - } - if max != 20 || cnt != 1 { - t.Fatalf("unexpected values: got max=%v, count=%v; expected max=20, cnt=1", max, cnt) + } else if vc, ok := resp.Results[0].(pilosa.ValCount); !ok { + t.Fatalf("expected ValCount; got %T", resp.Results[0]) + } else if vc.Val != 20 || vc.Count != 1 { + t.Fatalf("unexpected values: got max=%v, count=%v; expected max=20, cnt=1", vc.Val, vc.Count) } } @@ -1071,7 +1018,7 @@ func TestClient_ImportExistence(t *testing.T) { fldName := "fint" index := hldr.MustCreateIndexIfNotExists(idxName, pilosa.IndexOptions{TrackExistence: true}) - field, err := index.CreateFieldIfNotExists(fldName, pilosa.OptFieldTypeInt(-100, 100)) + _, err := index.CreateFieldIfNotExists(fldName, pilosa.OptFieldTypeInt(-100, 100)) if err != nil { t.Fatal(err) } @@ -1087,12 +1034,12 @@ func TestClient_ImportExistence(t *testing.T) { } // Verify Sum. - sum, cnt, err := field.Sum(nil, fldName) - if err != nil { + if resp, err := c.Query(context.Background(), idxName, &pilosa.QueryRequest{Query: fmt.Sprintf(`Sum(field=%s)`, fldName)}); err != nil { t.Fatal(err) - } - if sum != 50 || cnt != 3 { - t.Fatalf("unexpected values: got sum=%v, count=%v; expected sum=50, cnt=3", sum, cnt) + } else if vc, ok := resp.Results[0].(pilosa.ValCount); !ok { + t.Fatalf("expected ValCount; got %T", resp.Results[0]) + } else if vc.Val != 50 || vc.Count != 3 { + t.Fatalf("unexpected values: got sum=%v, count=%v; expected sum=50, cnt=3", vc.Val, vc.Count) } // Verify existence. diff --git a/view.go b/view.go index a851b8653..478725e1e 100644 --- a/view.go +++ b/view.go @@ -469,62 +469,6 @@ func (v *view) clearValue(columnID uint64, bitDepth uint, value int64) (changed return frag.clearValue(columnID, bitDepth, value) } -// sum returns the sum & count of a field. -func (v *view) sum(filter *Row, bitDepth uint) (sum int64, count uint64, err error) { - for _, f := range v.allFragments() { - fsum, fcount, err := f.sum(filter, bitDepth) - if err != nil { - return sum, count, err - } - sum += fsum - count += fcount - } - return sum, count, nil -} - -// min returns the min and count of a field. -func (v *view) min(filter *Row, bitDepth uint) (min int64, count uint64, err error) { - var minHasValue bool - for _, f := range v.allFragments() { - fmin, fcount, err := f.min(filter, bitDepth) - if err != nil { - return min, count, err - } - // Don't consider a min based on zero columns. - if fcount == 0 { - continue - } - - if !minHasValue { - min = fmin - minHasValue = true - count += fcount - continue - } - - if fmin < min { - min = fmin - count += fcount - } - } - return min, count, nil -} - -// max returns the max and count of a field. -func (v *view) max(filter *Row, bitDepth uint) (max int64, count uint64, err error) { - for _, f := range v.allFragments() { - fmax, fcount, err := f.max(filter, bitDepth) - if err != nil { - return max, count, err - } - if fcount > 0 && fmax > max { - max = fmax - count += fcount - } - } - return max, count, nil -} - // rangeOp returns rows with a field value encoding matching the predicate. func (v *view) rangeOp(op pql.Token, bitDepth uint, predicate int64) (*Row, error) { r := NewRow()