Merge pull request #200 from kuba--/groupby-int/124

Group by on ints
2026-09-07 09:05:55 +00:00 · 2020-04-08 01:47:17 +02:00 · 2020-04-08 01:47:17 +02:00 · 7868188670
commit 7868188670
parent 64caffebe8 1217deee1c
11 changed files with 889 additions and 244 deletions
--- a/cache.go
+++ b/cache.go
@ -422,6 +422,13 @@ func (p PairsField) MarshalJSON() ([]byte, error) {
 	return json.Marshal(p.Pairs)
 }

+// int64Slice represents a sortable slice of int64 numbers.
+type int64Slice []int64
+
+func (p int64Slice) Len() int           { return len(p) }
+func (p int64Slice) Less(i, j int) bool { return p[i] < p[j] }
+func (p int64Slice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
+
 // uint64Slice represents a sortable slice of uint64 numbers.
 type uint64Slice []uint64

--- a/encoding/proto/proto.go
+++ b/encoding/proto/proto.go
@ -1339,6 +1339,9 @@ func decodeFieldRows(a []*internal.FieldRow) []pilosa.FieldRow {
 		} else {
 			other[i].RowKey = fr.RowKey
 		}
+		if fr.Value != nil {
+			other[i].Value = &fr.Value.Value
+		}
 	}
 	return other
 }
@ -1470,6 +1473,9 @@ func encodeFieldRows(a []pilosa.FieldRow) []*internal.FieldRow {
 				Field: fr.Field,
 				RowID: fr.RowID,
 			}
+			if fr.Value != nil {
+				other[i].Value = &internal.Int64{Value: *fr.Value}
+			}
 		} else {
 			other[i] = &internal.FieldRow{
 				Field:  fr.Field,
--- a/executor.go
+++ b/executor.go
@ -20,6 +20,7 @@ import (
 	"fmt"
 	"math"
 	"sort"
+	"strings"
 	"sync"
 	"time"

@ -1685,6 +1686,7 @@ type FieldRow struct {
 	Field  string `json:"field"`
 	RowID  uint64 `json:"rowID"`
 	RowKey string `json:"rowKey,omitempty"`
+	Value  *int64 `json:"value,omitempty"`
 }

 // MarshalJSON marshals FieldRow to JSON such that
@ -1699,6 +1701,17 @@ func (fr FieldRow) MarshalJSON() ([]byte, error) {
 			RowKey: fr.RowKey,
 		})
 	}
+
+	if fr.Value != nil {
+		return json.Marshal(struct {
+			Field string `json:"field"`
+			Value int64  `json:"value"`
+		}{
+			Field: fr.Field,
+			Value: *fr.Value,
+		})
+	}
+
 	return json.Marshal(struct {
 		Field string `json:"field"`
 		RowID uint64 `json:"rowID"`
@ -1710,6 +1723,9 @@ func (fr FieldRow) MarshalJSON() ([]byte, error) {

 // String is the FieldRow stringer.
 func (fr FieldRow) String() string {
+	if fr.Value != nil {
+		return fmt.Sprintf("%s.%d.%d.%s", fr.Field, fr.RowID, *fr.Value, fr.RowKey)
+	}
 	return fmt.Sprintf("%s.%d.%s", fr.Field, fr.RowID, fr.RowKey)
 }

@ -1756,12 +1772,23 @@ func mergeGroupCounts(a, b []GroupCount, limit int) []GroupCount {

 // Compare is used in ordering two GroupCount objects.
 func (g GroupCount) Compare(o GroupCount) int {
-	for i := range g.Group {
-		if g.Group[i].RowID < o.Group[i].RowID {
-			return -1
-		}
-		if g.Group[i].RowID > o.Group[i].RowID {
-			return 1
+	for i, g1 := range g.Group {
+		g2 := o.Group[i]
+
+		if g1.Value != nil && g2.Value != nil {
+			if *g1.Value < *g2.Value {
+				return -1
+			}
+			if *g1.Value > *g2.Value {
+				return 1
+			}
+		} else {
+			if g1.RowID < g2.RowID {
+				return -1
+			}
+			if g1.RowID > g2.RowID {
+				return 1
+			}
 		}
 	}
 	return 0
@ -1939,6 +1966,7 @@ func (e *executor) executeGroupByShard(ctx context.Context, index string, c *pql
 		if err != nil {
 			return nil, err
 		}
+
 		if gc.Count > 0 {
 			num++
 			results = append(results, gc)
@ -4253,7 +4281,7 @@ type groupByIterator struct {
 	shard    uint64

 	// rowIters contains a rowIterator for each of the fields in the Group By.
-	rowIters []*rowIterator
+	rowIters []rowIterator
 	// rows contains the current row data for each of the fields in the Group
 	// By. Each row is the intersection of itself and the rows of the fields
 	// with an index lower than its own. This is a performance optimization so
@ -4261,8 +4289,9 @@ type groupByIterator struct {
 	// field to the right require only a single intersect with the row of the
 	// previous field to determine the count of the new group.
 	rows []struct {
-		row *Row
-		id  uint64
+		row   *Row
+		id    uint64
+		value *int64
 	}

 	// fields helps with the construction of GroupCount results by holding all
@ -4284,29 +4313,47 @@ func newGroupByIterator(executor *executor, rowIDs []RowIDs, children []*pql.Cal
 		executor: executor,
 		index:    index,
 		shard:    shard,
-		rowIters: make([]*rowIterator, len(children)),
+		rowIters: make([]rowIterator, len(children)),
 		rows: make([]struct {
-			row *Row
-			id  uint64
+			row   *Row
+			id    uint64
+			value *int64
 		}, len(children)),
 		filter:    filter,
 		aggregate: aggregate,
 		fields:    make([]FieldRow, len(children)),
 	}

-	var fieldName string
-	var ok bool
+	var (
+		fieldName string
+		viewName  string
+		ok        bool
+	)
 	ignorePrev := false
 	for i, call := range children {
 		if fieldName, ok = call.Args["_field"].(string); !ok {
 			return nil, errors.Errorf("%s call must have field with valid (string) field name. Got %v of type %[2]T", call.Name, call.Args["_field"])
 		}
-		if holder.Field(index, fieldName) == nil {
+		field := holder.Field(index, fieldName)
+		if field == nil {
 			return nil, ErrFieldNotFound
 		}
 		gbi.fields[i].Field = fieldName
+
+		switch field.Type() {
+		case FieldTypeSet, FieldTypeTime, FieldTypeMutex, FieldTypeBool:
+			viewName = viewStandard
+
+		case FieldTypeInt:
+			viewName = viewBSIGroupPrefix + fieldName
+
+		default: // FieldTypeDecimal
+			return nil, errors.Errorf("%s call must have field of one of types: %s",
+				call.Name, strings.Join([]string{FieldTypeSet, FieldTypeTime, FieldTypeMutex, FieldTypeBool, FieldTypeInt}, ","))
+		}
+
 		// Fetch fragment.
-		frag := holder.fragment(index, fieldName, viewStandard, shard)
+		frag := holder.fragment(index, fieldName, viewName, shard)
 		if frag == nil { // this means this whole shard doesn't have all it needs to continue
 			return nil, nil
 		}
@ -4325,13 +4372,14 @@ func newGroupByIterator(executor *executor, rowIDs []RowIDs, children []*pql.Cal
 			}
 			gbi.rowIters[i].Seek(prev)
 		}
-		nextRow, rowID, wrapped := gbi.rowIters[i].Next()
+		nextRow, rowID, value, wrapped := gbi.rowIters[i].Next()
 		if nextRow == nil {
 			gbi.done = true
 			return gbi, nil
 		}
 		gbi.rows[i].row = nextRow
 		gbi.rows[i].id = rowID
+		gbi.rows[i].value = value
 		if hasPrev && rowID != prev {
 			// ignorePrev signals that we didn't find a previous row, so all
 			// Rows queries "deeper" than it need to ignore the previous
@ -4343,13 +4391,14 @@ func newGroupByIterator(executor *executor, rowIDs []RowIDs, children []*pql.Cal
 			// previous field, and if that one wraps we need to keep going
 			// backward.
 			for j := i - 1; j >= 0; j-- {
-				nextRow, rowID, wrapped := gbi.rowIters[j].Next()
+				nextRow, rowID, value, wrapped := gbi.rowIters[j].Next()
 				if nextRow == nil {
 					gbi.done = true
 					return gbi, nil
 				}
 				gbi.rows[j].row = nextRow
 				gbi.rows[j].id = rowID
+				gbi.rows[j].value = value
 				if !wrapped {
 					break
 				}
@ -4374,7 +4423,7 @@ func newGroupByIterator(executor *executor, rowIDs []RowIDs, children []*pql.Cal
 func (gbi *groupByIterator) nextAtIdx(i int) {
 	// loop until we find a non-empty row. This is an optimization - the loop and if/break can be removed.
 	for {
-		nr, rowID, wrapped := gbi.rowIters[i].Next()
+		nr, rowID, value, wrapped := gbi.rowIters[i].Next()
 		if nr == nil {
 			gbi.done = true
 			return
@ -4390,6 +4439,7 @@ func (gbi *groupByIterator) nextAtIdx(i int) {
 			gbi.rows[i].row = nr.Intersect(gbi.rows[i-1].row)
 		}
 		gbi.rows[i].id = rowID
+		gbi.rows[i].value = value

 		if !gbi.rows[i].row.IsEmpty() {
 			break
@ -4412,7 +4462,8 @@ func (gbi *groupByIterator) Next(ctx context.Context) (ret GroupCount, done bool
 				ret.Count = gbi.rows[len(gbi.rows)-1].row.intersectionCount(gbi.rows[len(gbi.rows)-2].row)
 			}
 		} else {
-			filter := gbi.rows[len(gbi.rows)-1].row
+			gr := gbi.rows[len(gbi.rows)-1]
+			filter := gr.row
 			if len(gbi.rows) != 1 {
 				filter = filter.Intersect(gbi.rows[len(gbi.rows)-2].row)
 			}
@ -4437,11 +4488,12 @@ func (gbi *groupByIterator) Next(ctx context.Context) (ret GroupCount, done bool
 	ret.Group = make([]FieldRow, len(gbi.rows))
 	copy(ret.Group, gbi.fields)
 	for i, r := range gbi.rows {
+
 		ret.Group[i].RowID = r.id
+		ret.Group[i].Value = r.value
 	}

 	// set up for next call
-
 	gbi.nextAtIdx(len(gbi.rows) - 1)

 	return ret, false, nil
--- a/executor_test.go
+++ b/executor_test.go
@ -2762,16 +2762,16 @@ func TestExecutor_Execute_Remote_Row(t *testing.T) {
 			t.Fatalf("creating field: %v", err)
 		}
 		if _, err := c[0].API.Query(context.Background(), &pilosa.QueryRequest{Index: "i", Query: `
-Set(500001, fn=5)
-Set(1500001, fn=5)
-Set(2500001, fn=5)
-Set(3500001, fn=5)
-Set(1500001, fn=3)
-Set(1500002, fn=3)
-Set(3500003, fn=3)
-Set(500001, fn=4)
-Set(4500001, fn=4)
-`}); err != nil {
+	Set(500001, fn=5)
+	Set(1500001, fn=5)
+	Set(2500001, fn=5)
+	Set(3500001, fn=5)
+	Set(1500001, fn=3)
+	Set(1500002, fn=3)
+	Set(3500003, fn=3)
+	Set(500001, fn=4)
+	Set(4500001, fn=4)
+	`}); err != nil {
 			t.Fatalf("querying remote: %v", err)
 		}
 		err := c[0].API.RecalculateCaches(context.Background())
@ -2822,6 +2822,48 @@ Set(4500001, fn=4)
 			test.CheckGroupBy(t, expected, results)
 		}
 	})
+
+	t.Run("remote groupBy on ints", func(t *testing.T) {
+		_, err = c[0].API.CreateField(context.Background(), "i", "fint", pilosa.OptFieldTypeInt(-1000, 1000))
+		if err != nil {
+			t.Fatalf("creating field: %v", err)
+		}
+		if _, err := c[0].API.Query(context.Background(), &pilosa.QueryRequest{Index: "i", Query: `
+		Set(0, fint=1)
+		Set(1, fint=2)
+
+		Set(2,fint=-2)
+		Set(3,fint=-1)
+
+		Set(4,fint=4)
+
+		Set(10, fint=0)
+		Set(100, fint=0)
+		Set(1000, fint=0)
+		Set(10000,fint=0)
+		Set(100000,fint=0)
+		`}); err != nil {
+			t.Fatalf("querying remote: %v", err)
+		}
+
+		if res, err := c[1].API.Query(context.Background(), &pilosa.QueryRequest{
+			Index: "i",
+			Query: `GroupBy(Rows(fint), limit=4, filter=Union(Row(fint < 1), Row(fint > 2)))`,
+		}); err != nil {
+			t.Fatalf("GroupBy querying: %v", err)
+		} else {
+			var a, b, c, d int64 = -2, -1, 0, 4
+			expected := []pilosa.GroupCount{
+				{Group: []pilosa.FieldRow{{Field: "fint", RowID: 0, Value: &a}}, Count: 1},
+				{Group: []pilosa.FieldRow{{Field: "fint", RowID: 1, Value: &b}}, Count: 1},
+				{Group: []pilosa.FieldRow{{Field: "fint", RowID: 2, Value: &c}}, Count: 5},
+				{Group: []pilosa.FieldRow{{Field: "fint", RowID: 5, Value: &d}}, Count: 1},
+			}
+
+			results := res.Results[0].([]pilosa.GroupCount)
+			test.CheckGroupBy(t, expected, results)
+		}
+	})
 }

 // Ensure executor returns an error if too many writes are in a single request.
@ -3890,6 +3932,7 @@ func TestExecutor_Execute_Query_Error(t *testing.T) {
 	c := test.MustRunCluster(t, 1)
 	defer c.Close()
 	c.CreateField(t, "i", pilosa.IndexOptions{}, "general")
+	c.CreateField(t, "i", pilosa.IndexOptions{}, "integer", pilosa.OptFieldTypeInt(-1000, 1000))

 	tests := []struct {
 		query string
@ -3919,6 +3962,10 @@ func TestExecutor_Execute_Query_Error(t *testing.T) {
 			query: "GroupBy(Rows(general), filter=Rows(general))",
 			error: "parsing: parsing:",
 		},
+		{
+			query: "GroupBy(Rows(integer), prev=-1)",
+			error: "unknown arg 'prev'",
+		},
 	}

 	for i, test := range tests {
@ -3942,6 +3989,8 @@ func TestExecutor_GroupByStrings(t *testing.T) {
 	defer c.Close()
 	c.CreateField(t, "istring", pilosa.IndexOptions{Keys: true}, "generals", pilosa.OptFieldKeys())
 	c.CreateField(t, "istring", pilosa.IndexOptions{Keys: true}, "v", pilosa.OptFieldTypeInt(0, 1000))
+	c.CreateField(t, "istring", pilosa.IndexOptions{Keys: true}, "vv", pilosa.OptFieldTypeInt(0, 1000))
+	c.CreateField(t, "istring", pilosa.IndexOptions{Keys: true}, "nv", pilosa.OptFieldTypeInt(-1000, 1000))

 	if err := c[0].API.Import(context.Background(), &pilosa.ImportRequest{
 		Index:      "istring",
@ -3953,12 +4002,34 @@ func TestExecutor_GroupByStrings(t *testing.T) {
 		t.Fatalf("importing: %v", err)
 	}

+	var v1, v2, v3, v4, v5, v6, v7, v8, v9, v10 int64 = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
+	var nv1, nv2, nv3, nv4 int64 = -1, -2, -3, -4
 	if err := c[0].API.ImportValue(context.Background(), &pilosa.ImportValueRequest{
 		Index:      "istring",
 		Field:      "v",
 		Shard:      0,
 		ColumnKeys: []string{"c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "c10"},
-		Values:     []int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+		Values:     []int64{v1, v2, v3, v4, v5, v6, v7, v8, v9, v10},
+	}); err != nil {
+		t.Fatalf("importing: %v", err)
+	}
+
+	if err := c[0].API.ImportValue(context.Background(), &pilosa.ImportValueRequest{
+		Index:      "istring",
+		Field:      "vv",
+		Shard:      0,
+		ColumnKeys: []string{"c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "c10"},
+		Values:     []int64{v1, v2, v2, v3, v3, v3, v4, v4, v4, v4},
+	}); err != nil {
+		t.Fatalf("importing: %v", err)
+	}
+
+	if err := c[0].API.ImportValue(context.Background(), &pilosa.ImportValueRequest{
+		Index:      "istring",
+		Field:      "nv",
+		Shard:      0,
+		ColumnKeys: []string{"c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "c10"},
+		Values:     []int64{nv1, nv2, nv2, nv3, nv3, nv3, nv4, nv4, nv4, nv4},
 	}); err != nil {
 		t.Fatalf("importing: %v", err)
 	}
@ -4003,6 +4074,127 @@ func TestExecutor_GroupByStrings(t *testing.T) {
 			query:    "GroupBy(Rows(generals), aggregate=Sum(field=v), having=Condition(count>5))",
 			expected: []pilosa.GroupCount{},
 		},
+		{
+			query: "GroupBy(Rows(v))",
+			expected: []pilosa.GroupCount{
+				{
+					Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "v", Value: &v1}},
+					Count: 1,
+					Sum:   0,
+				},
+				{
+					Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "v", Value: &v2}},
+					Count: 1,
+					Sum:   0,
+				},
+				{
+					Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "v", Value: &v3}},
+					Count: 1,
+					Sum:   0,
+				},
+				{
+					Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "v", Value: &v4}},
+					Count: 1,
+					Sum:   0,
+				},
+				{
+					Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "v", Value: &v5}},
+					Count: 1,
+					Sum:   0,
+				},
+				{
+					Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "v", Value: &v6}},
+					Count: 1,
+					Sum:   0,
+				},
+				{
+					Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "v", Value: &v7}},
+					Count: 1,
+					Sum:   0,
+				},
+				{
+					Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "v", Value: &v8}},
+					Count: 1,
+					Sum:   0,
+				},
+				{
+					Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "v", Value: &v9}},
+					Count: 1,
+					Sum:   0,
+				},
+				{
+					Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "v", Value: &v10}},
+					Count: 1,
+					Sum:   0,
+				},
+			},
+		},
+		{
+			query: "GroupBy(Rows(vv), aggregate=Sum(field=vv), having=Condition(count > 2))",
+			expected: []pilosa.GroupCount{
+				{
+					Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "vv", Value: &v3}},
+					Count: 3,
+					Sum:   9,
+				},
+				{
+					Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "vv", Value: &v4}},
+					Count: 4,
+					Sum:   16,
+				},
+			},
+		},
+		{
+			query: "GroupBy(Rows(nv), aggregate=Sum(field=nv), limit=2)",
+			expected: []pilosa.GroupCount{
+				{
+					Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "nv", Value: &nv4}},
+					Count: 4,
+					Sum:   -16,
+				},
+				{
+					Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "nv", Value: &nv3}},
+					Count: 3,
+					Sum:   -9,
+				},
+			},
+		},
+		{
+			query: "GroupBy(Rows(nv), aggregate=Sum(field=nv), having=Condition(count > 2), limit=2)",
+			expected: []pilosa.GroupCount{
+				{
+					Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "nv", Value: &nv4}},
+					Count: 4,
+					Sum:   -16,
+				},
+				{
+					Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "nv", Value: &nv3}},
+					Count: 3,
+					Sum:   -9,
+				},
+			},
+		},
+		{
+			query: "GroupBy(Rows(vv), Rows(nv), aggregate=Sum(field=vv), having=Condition(count > 2))",
+			expected: []pilosa.GroupCount{
+				{
+					Group: []pilosa.FieldRow{
+						pilosa.FieldRow{Field: "vv", Value: &v3},
+						pilosa.FieldRow{Field: "nv", Value: &nv3},
+					},
+					Count: 3,
+					Sum:   9,
+				},
+				{
+					Group: []pilosa.FieldRow{
+						pilosa.FieldRow{Field: "vv", Value: &v4},
+						pilosa.FieldRow{Field: "nv", Value: &nv4},
+					},
+					Count: 4,
+					Sum:   16,
+				},
+			},
+		},
 	}

 	for i, tst := range tests {
--- a/fragment.go
+++ b/fragment.go
@ -2717,40 +2717,183 @@ func upgradeRoaringBSIv2(f *fragment, bitDepth uint) (string, error) {
 	return newPath, nil
 }

-type rowIterator struct {
+type rowIterator interface {
+	// TODO(kuba) linter suggests to use io.Seeker
+	// Seek(offset int64, whence int) (int64, error)
+	Seek(uint64)
+
+	Next() (*Row, uint64, *int64, bool)
+}
+
+func (f *fragment) rowIterator(wrap bool, filters ...rowFilter) rowIterator {
+	if strings.HasPrefix(f.view, viewBSIGroupPrefix) {
+		return f.intRowIterator(wrap, filters...)
+	}
+	// viewStandard
+	// TODO(kuba) - IMHO we should check if f.view is viewStandard,
+	// but because of testing the function returns set iterator as default one.
+	return f.setRowIterator(wrap, filters...)
+}
+
+type intRowIterator struct {
+	f      *fragment
+	values int64Slice         // sorted slice of int values
+	colIDs map[int64][]uint64 // [int value] -> [column IDs]
+	cur    int                // current value index (rowID)
+	wrap   bool
+}
+
+func (f *fragment) intRowIterator(wrap bool, filters ...rowFilter) rowIterator {
+	it := intRowIterator{
+		f:      f,
+		colIDs: make(map[int64][]uint64),
+		cur:    0,
+		wrap:   wrap,
+	}
+
+	// accumulator [column ID] -> [int value]
+	acc := make(map[uint64]int64)
+
+	f.mu.RLock()
+	defer f.mu.RUnlock()
+	f.foreachRow(filters, func(rid uint64) {
+		// skip exist(0) and sign(1) rows
+		if rid == bsiExistsBit || rid == bsiSignBit {
+			return
+		}
+
+		val := int64(1 << (rid - bsiOffsetBit))
+		for _, cid := range f.unprotectedRow(rid).Columns() {
+			acc[cid] |= val
+		}
+	})
+
+	// apply exist and sign bits
+	allCols := f.unprotectedRow(0).Columns()
+	signCols := f.unprotectedRow(1).Columns()
+	signIdx, signLen := 0, len(signCols)
+
+	// all distinct values
+	values := make(map[int64]struct{})
+	for _, cid := range allCols {
+		// apply sign bit
+		if signIdx < signLen && cid == signCols[signIdx] {
+			if tmp, ok := acc[cid]; ok {
+				acc[cid] = -tmp
+			}
+
+			signIdx++
+		}
+
+		val := acc[cid]
+		it.colIDs[val] = append(it.colIDs[val], cid)
+
+		if _, ok := values[val]; !ok {
+			it.values = append(it.values, val)
+			values[val] = struct{}{}
+		}
+	}
+	sort.Sort(it.values)
+
+	return &it
+}
+
+func (f *fragment) foreachRow(filters []rowFilter, fn func(rid uint64)) {
+	var lastRow uint64 = math.MaxUint64
+	i, _ := f.storage.Containers.Iterator(rowToKey(0))
+	// Loop over the existing containers.
+	for i.Next() {
+		key, c := i.Value()
+		// virtual row for the current container
+		vRow := key >> shardVsContainerExponent
+		// skip dups
+		if vRow == lastRow {
+			continue
+		}
+
+		// apply filters
+		addRow, done := true, false
+		for _, filter := range filters {
+			var d bool
+			addRow, d = filter(vRow, key, c)
+			done = done || d
+			if !addRow {
+				break
+			}
+		}
+		if addRow {
+			lastRow = vRow
+			if fn != nil {
+				fn(vRow)
+			}
+		}
+		if done {
+			break
+		}
+	}
+}
+
+func (it *intRowIterator) Seek(rowID uint64) {
+	idx := sort.Search(len(it.values), func(i int) bool {
+		return it.values[i] >= it.values[rowID]
+	})
+	it.cur = idx
+}
+
+func (it *intRowIterator) Next() (r *Row, rowID uint64, value *int64, wrapped bool) {
+	if it.cur >= len(it.values) {
+		if !it.wrap || len(it.values) == 0 {
+			return nil, 0, nil, true
+		}
+		wrapped = true
+		it.cur = 0
+	}
+	if it.cur >= 0 {
+		rowID = uint64(it.cur)
+		value = &it.values[rowID]
+		r = NewRow(it.colIDs[*value]...)
+	}
+	it.cur++
+	return r, rowID, value, wrapped
+}
+
+type setRowIterator struct {
 	f      *fragment
 	rowIDs []uint64
 	cur    int
 	wrap   bool
 }

-func (f *fragment) rowIterator(wrap bool, filters ...rowFilter) *rowIterator {
-	return &rowIterator{
+func (f *fragment) setRowIterator(wrap bool, filters ...rowFilter) rowIterator {
+	return &setRowIterator{
 		f:      f,
 		rowIDs: f.rows(0, filters...), // TODO: this may be memory intensive in high cardinality cases
 		wrap:   wrap,
 	}
 }

-func (ri *rowIterator) Seek(rowID uint64) {
-	idx := sort.Search(len(ri.rowIDs), func(i int) bool {
-		return ri.rowIDs[i] >= rowID
+func (it *setRowIterator) Seek(rowID uint64) {
+	idx := sort.Search(len(it.rowIDs), func(i int) bool {
+		return it.rowIDs[i] >= rowID
 	})
-	ri.cur = idx
+	it.cur = idx
 }

-func (ri *rowIterator) Next() (r *Row, rowID uint64, wrapped bool) {
-	if ri.cur >= len(ri.rowIDs) {
-		if !ri.wrap || len(ri.rowIDs) == 0 {
-			return nil, 0, true
+func (it *setRowIterator) Next() (r *Row, rowID uint64, _ *int64, wrapped bool) {
+	if it.cur >= len(it.rowIDs) {
+		if !it.wrap || len(it.rowIDs) == 0 {
+			return nil, 0, nil, true
 		}
-		ri.Seek(0)
+		it.Seek(0)
 		wrapped = true
 	}
-	rowID = ri.rowIDs[ri.cur]
-	r = ri.f.row(rowID)
-	ri.cur++
-	return r, rowID, wrapped
+	id := it.rowIDs[it.cur]
+	r = it.f.row(id)
+
+	rowID = id
+
+	it.cur++
+	return r, rowID, nil, wrapped
 }

 // FragmentBlock represents info about a subsection of the rows in a block.
--- a/fragment_internal_test.go
+++ b/fragment_internal_test.go
@ -2989,7 +2989,7 @@ func TestFragmentRowIterator(t *testing.T) {

 		iter := f.rowIterator(false)
 		for i := uint64(0); i < 4; i++ {
-			row, id, wrapped := iter.Next()
+			row, id, _, wrapped := iter.Next()
 			if id != i {
 				t.Fatalf("expected row %d but got %d", i, id)
 			}
@ -3000,7 +3000,7 @@ func TestFragmentRowIterator(t *testing.T) {
 				t.Fatalf("got wrong columns back on iteration %d - should just be 0 but %v", i, row.Columns())
 			}
 		}
-		row, id, wrapped := iter.Next()
+		row, id, _, wrapped := iter.Next()
 		if row != nil {
 			t.Fatalf("row should be nil after iterator is exhausted, got %v", row.Columns())
 		}
@ -3022,7 +3022,7 @@ func TestFragmentRowIterator(t *testing.T) {

 		iter := f.rowIterator(false)
 		for i := uint64(1); i < 8; i += 2 {
-			row, id, wrapped := iter.Next()
+			row, id, _, wrapped := iter.Next()
 			if id != i {
 				t.Fatalf("expected row %d but got %d", i, id)
 			}
@ -3033,7 +3033,7 @@ func TestFragmentRowIterator(t *testing.T) {
 				t.Fatalf("got wrong columns back on iteration %d - should just be 0 but %v", i, row.Columns())
 			}
 		}
-		row, id, wrapped := iter.Next()
+		row, id, _, wrapped := iter.Next()
 		if row != nil {
 			t.Fatalf("row should be nil after iterator is exhausted, got %v", row.Columns())
 		}
@ -3055,7 +3055,7 @@ func TestFragmentRowIterator(t *testing.T) {

 		iter := f.rowIterator(true)
 		for i := uint64(0); i < 5; i++ {
-			row, id, wrapped := iter.Next()
+			row, id, _, wrapped := iter.Next()
 			if id != i%4 {
 				t.Fatalf("expected row %d but got %d", i%4, id)
 			}
@ -3080,7 +3080,7 @@ func TestFragmentRowIterator(t *testing.T) {

 		iter := f.rowIterator(true)
 		for i := uint64(1); i < 10; i += 2 {
-			row, id, wrapped := iter.Next()
+			row, id, _, wrapped := iter.Next()
 			if id != i%8 {
 				t.Errorf("expected row %d but got %d", i%8, id)
 			}
--- a/go.sum
+++ b/go.sum
@ -227,8 +227,6 @@ google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55 h1:gSJIx1SDwno+2El
 google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
-google.golang.org/grpc v1.24.0 h1:vb/1TCsVn3DcJlQ0Gs1yB1pKI6Do2/QNwxdKqmc/b0s=
-google.golang.org/grpc v1.24.0/go.mod h1:XDChyiUovWa60DnaeDeZmSW86xtLtjtZbwvSiRnRtcA=
 google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
 google.golang.org/grpc v1.28.0 h1:bO/TA4OxCOummhSf10siHuG7vJOiwh7SpRpFZDkOgl4=
 google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60=
--- a/internal/public.pb.go
+++ b/internal/public.pb.go
@ -377,10 +377,58 @@ func (m *PairsField) GetField() string {
 	return ""
 }

+type Int64 struct {
+	Value                int64    `protobuf:"varint,1,opt,name=Value,proto3" json:"Value,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Int64) Reset()         { *m = Int64{} }
+func (m *Int64) String() string { return proto.CompactTextString(m) }
+func (*Int64) ProtoMessage()    {}
+func (*Int64) Descriptor() ([]byte, []int) {
+	return fileDescriptor_413a91106d7bcce8, []int{6}
+}
+func (m *Int64) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Int64) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Int64.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *Int64) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Int64.Merge(m, src)
+}
+func (m *Int64) XXX_Size() int {
+	return m.Size()
+}
+func (m *Int64) XXX_DiscardUnknown() {
+	xxx_messageInfo_Int64.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Int64 proto.InternalMessageInfo
+
+func (m *Int64) GetValue() int64 {
+	if m != nil {
+		return m.Value
+	}
+	return 0
+}
+
 type FieldRow struct {
 	Field                string   `protobuf:"bytes,1,opt,name=Field,proto3" json:"Field,omitempty"`
 	RowID                uint64   `protobuf:"varint,2,opt,name=RowID,proto3" json:"RowID,omitempty"`
 	RowKey               string   `protobuf:"bytes,3,opt,name=RowKey,proto3" json:"RowKey,omitempty"`
+	Value                *Int64   `protobuf:"bytes,4,opt,name=Value,proto3" json:"Value,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@ -390,7 +438,7 @@ func (m *FieldRow) Reset()         { *m = FieldRow{} }
 func (m *FieldRow) String() string { return proto.CompactTextString(m) }
 func (*FieldRow) ProtoMessage()    {}
 func (*FieldRow) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{6}
+	return fileDescriptor_413a91106d7bcce8, []int{7}
 }
 func (m *FieldRow) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -440,6 +488,13 @@ func (m *FieldRow) GetRowKey() string {
 	return ""
 }

+func (m *FieldRow) GetValue() *Int64 {
+	if m != nil {
+		return m.Value
+	}
+	return nil
+}
+
 type GroupCount struct {
 	Group                []*FieldRow `protobuf:"bytes,1,rep,name=Group,proto3" json:"Group,omitempty"`
 	Count                uint64      `protobuf:"varint,2,opt,name=Count,proto3" json:"Count,omitempty"`
@ -453,7 +508,7 @@ func (m *GroupCount) Reset()         { *m = GroupCount{} }
 func (m *GroupCount) String() string { return proto.CompactTextString(m) }
 func (*GroupCount) ProtoMessage()    {}
 func (*GroupCount) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{7}
+	return fileDescriptor_413a91106d7bcce8, []int{8}
 }
 func (m *GroupCount) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -517,7 +572,7 @@ func (m *ValCount) Reset()         { *m = ValCount{} }
 func (m *ValCount) String() string { return proto.CompactTextString(m) }
 func (*ValCount) ProtoMessage()    {}
 func (*ValCount) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{8}
+	return fileDescriptor_413a91106d7bcce8, []int{9}
 }
 func (m *ValCount) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -586,7 +641,7 @@ func (m *Decimal) Reset()         { *m = Decimal{} }
 func (m *Decimal) String() string { return proto.CompactTextString(m) }
 func (*Decimal) ProtoMessage()    {}
 func (*Decimal) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{9}
+	return fileDescriptor_413a91106d7bcce8, []int{10}
 }
 func (m *Decimal) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -642,7 +697,7 @@ func (m *ColumnAttrSet) Reset()         { *m = ColumnAttrSet{} }
 func (m *ColumnAttrSet) String() string { return proto.CompactTextString(m) }
 func (*ColumnAttrSet) ProtoMessage()    {}
 func (*ColumnAttrSet) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{10}
+	return fileDescriptor_413a91106d7bcce8, []int{11}
 }
 func (m *ColumnAttrSet) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -708,7 +763,7 @@ func (m *Attr) Reset()         { *m = Attr{} }
 func (m *Attr) String() string { return proto.CompactTextString(m) }
 func (*Attr) ProtoMessage()    {}
 func (*Attr) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{11}
+	return fileDescriptor_413a91106d7bcce8, []int{12}
 }
 func (m *Attr) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -790,7 +845,7 @@ func (m *AttrMap) Reset()         { *m = AttrMap{} }
 func (m *AttrMap) String() string { return proto.CompactTextString(m) }
 func (*AttrMap) ProtoMessage()    {}
 func (*AttrMap) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{12}
+	return fileDescriptor_413a91106d7bcce8, []int{13}
 }
 func (m *AttrMap) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -843,7 +898,7 @@ func (m *QueryRequest) Reset()         { *m = QueryRequest{} }
 func (m *QueryRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryRequest) ProtoMessage()    {}
 func (*QueryRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{13}
+	return fileDescriptor_413a91106d7bcce8, []int{14}
 }
 func (m *QueryRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -934,7 +989,7 @@ func (m *QueryResponse) Reset()         { *m = QueryResponse{} }
 func (m *QueryResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryResponse) ProtoMessage()    {}
 func (*QueryResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{14}
+	return fileDescriptor_413a91106d7bcce8, []int{15}
 }
 func (m *QueryResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1005,7 +1060,7 @@ func (m *QueryResult) Reset()         { *m = QueryResult{} }
 func (m *QueryResult) String() string { return proto.CompactTextString(m) }
 func (*QueryResult) ProtoMessage()    {}
 func (*QueryResult) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{15}
+	return fileDescriptor_413a91106d7bcce8, []int{16}
 }
 func (m *QueryResult) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1129,7 +1184,7 @@ func (m *ImportRequest) Reset()         { *m = ImportRequest{} }
 func (m *ImportRequest) String() string { return proto.CompactTextString(m) }
 func (*ImportRequest) ProtoMessage()    {}
 func (*ImportRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{16}
+	return fileDescriptor_413a91106d7bcce8, []int{17}
 }
 func (m *ImportRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1232,7 +1287,7 @@ func (m *ImportValueRequest) Reset()         { *m = ImportValueRequest{} }
 func (m *ImportValueRequest) String() string { return proto.CompactTextString(m) }
 func (*ImportValueRequest) ProtoMessage()    {}
 func (*ImportValueRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{17}
+	return fileDescriptor_413a91106d7bcce8, []int{18}
 }
 func (m *ImportValueRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1330,7 +1385,7 @@ func (m *TranslateKeysRequest) Reset()         { *m = TranslateKeysRequest{} }
 func (m *TranslateKeysRequest) String() string { return proto.CompactTextString(m) }
 func (*TranslateKeysRequest) ProtoMessage()    {}
 func (*TranslateKeysRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{18}
+	return fileDescriptor_413a91106d7bcce8, []int{19}
 }
 func (m *TranslateKeysRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1391,7 +1446,7 @@ func (m *TranslateKeysResponse) Reset()         { *m = TranslateKeysResponse{} }
 func (m *TranslateKeysResponse) String() string { return proto.CompactTextString(m) }
 func (*TranslateKeysResponse) ProtoMessage()    {}
 func (*TranslateKeysResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{19}
+	return fileDescriptor_413a91106d7bcce8, []int{20}
 }
 func (m *TranslateKeysResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1440,7 +1495,7 @@ func (m *TranslateIDsRequest) Reset()         { *m = TranslateIDsRequest{} }
 func (m *TranslateIDsRequest) String() string { return proto.CompactTextString(m) }
 func (*TranslateIDsRequest) ProtoMessage()    {}
 func (*TranslateIDsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{20}
+	return fileDescriptor_413a91106d7bcce8, []int{21}
 }
 func (m *TranslateIDsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1501,7 +1556,7 @@ func (m *TranslateIDsResponse) Reset()         { *m = TranslateIDsResponse{} }
 func (m *TranslateIDsResponse) String() string { return proto.CompactTextString(m) }
 func (*TranslateIDsResponse) ProtoMessage()    {}
 func (*TranslateIDsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{21}
+	return fileDescriptor_413a91106d7bcce8, []int{22}
 }
 func (m *TranslateIDsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1549,7 +1604,7 @@ func (m *ImportRoaringRequestView) Reset()         { *m = ImportRoaringRequestVi
 func (m *ImportRoaringRequestView) String() string { return proto.CompactTextString(m) }
 func (*ImportRoaringRequestView) ProtoMessage()    {}
 func (*ImportRoaringRequestView) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{22}
+	return fileDescriptor_413a91106d7bcce8, []int{23}
 }
 func (m *ImportRoaringRequestView) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1606,7 +1661,7 @@ func (m *ImportRoaringRequest) Reset()         { *m = ImportRoaringRequest{} }
 func (m *ImportRoaringRequest) String() string { return proto.CompactTextString(m) }
 func (*ImportRoaringRequest) ProtoMessage()    {}
 func (*ImportRoaringRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{23}
+	return fileDescriptor_413a91106d7bcce8, []int{24}
 }
 func (m *ImportRoaringRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1678,7 +1733,7 @@ func (m *ImportColumnAttrsRequest) Reset()         { *m = ImportColumnAttrsReque
 func (m *ImportColumnAttrsRequest) String() string { return proto.CompactTextString(m) }
 func (*ImportColumnAttrsRequest) ProtoMessage()    {}
 func (*ImportColumnAttrsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{24}
+	return fileDescriptor_413a91106d7bcce8, []int{25}
 }
 func (m *ImportColumnAttrsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1749,6 +1804,7 @@ func init() {
 	proto.RegisterType((*Pair)(nil), "internal.Pair")
 	proto.RegisterType((*PairField)(nil), "internal.PairField")
 	proto.RegisterType((*PairsField)(nil), "internal.PairsField")
+	proto.RegisterType((*Int64)(nil), "internal.Int64")
 	proto.RegisterType((*FieldRow)(nil), "internal.FieldRow")
 	proto.RegisterType((*GroupCount)(nil), "internal.GroupCount")
 	proto.RegisterType((*ValCount)(nil), "internal.ValCount")
@ -1773,81 +1829,82 @@ func init() {
 func init() { proto.RegisterFile("public.proto", fileDescriptor_413a91106d7bcce8) }

 var fileDescriptor_413a91106d7bcce8 = []byte{
-	// 1175 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xcd, 0x8e, 0x1b, 0xc5,
-	0x13, 0xff, 0xb7, 0x67, 0xbc, 0xb6, 0xcb, 0xde, 0xfd, 0x87, 0x8e, 0x13, 0x46, 0x28, 0xda, 0x58,
-	0xad, 0x08, 0x19, 0x0e, 0x1b, 0x65, 0xf9, 0x50, 0x4e, 0x40, 0x36, 0xde, 0x80, 0x15, 0xc5, 0x0a,
-	0xed, 0x95, 0xb9, 0x21, 0xcd, 0xda, 0xcd, 0x66, 0xc4, 0x78, 0xc6, 0xcc, 0x07, 0xce, 0x1e, 0x79,
-	0x06, 0x38, 0x20, 0x9e, 0x80, 0x77, 0xe0, 0x05, 0x38, 0xf2, 0x08, 0xb0, 0xbc, 0x01, 0x57, 0x2e,
-	0xa8, 0xaa, 0xa7, 0xdd, 0x6d, 0xaf, 0x77, 0x89, 0x22, 0x6e, 0xfd, 0xab, 0xaa, 0xae, 0xae, 0xaa,
-	0xa9, 0xfe, 0x55, 0x0f, 0x74, 0x16, 0xe5, 0x69, 0x1c, 0x4d, 0x0f, 0x16, 0x59, 0x5a, 0xa4, 0xbc,
-	0x19, 0x25, 0x85, 0xca, 0x92, 0x30, 0x16, 0x39, 0x78, 0x32, 0x5d, 0xf2, 0x00, 0x1a, 0x8f, 0xd3,
-	0xb8, 0x9c, 0x27, 0x79, 0xc0, 0x7a, 0x5e, 0xdf, 0x97, 0x06, 0x72, 0x0e, 0xfe, 0x53, 0x75, 0x9e,
-	0x07, 0x5e, 0xcf, 0xeb, 0xb7, 0x24, 0xad, 0xf9, 0x3d, 0xa8, 0x3f, 0x2a, 0x8a, 0x2c, 0x0f, 0x6a,
-	0x3d, 0xaf, 0xdf, 0x3e, 0xdc, 0x3b, 0x30, 0xee, 0x0e, 0x50, 0x2c, 0xb5, 0x12, 0x7d, 0xca, 0x34,
-	0xcc, 0xa2, 0xe4, 0x2c, 0xf0, 0x7b, 0xac, 0xdf, 0x91, 0x06, 0x8a, 0x67, 0xd0, 0x1a, 0x47, 0x67,
-	0x89, 0x9a, 0xe1, 0xd1, 0x77, 0xc1, 0x7b, 0x9e, 0xe2, 0xb1, 0xac, 0xdf, 0x3e, 0xdc, 0xb5, 0xae,
-	0x64, 0xba, 0x94, 0xa8, 0x41, 0x83, 0x91, 0x3a, 0x0b, 0x6a, 0x5b, 0x0d, 0x46, 0xea, 0x4c, 0x3c,
-	0x84, 0x3d, 0x99, 0x2e, 0x87, 0x33, 0x95, 0x14, 0xd1, 0x57, 0x91, 0xca, 0x28, 0x68, 0x99, 0x2e,
-	0x4d, 0x2e, 0xb4, 0x5e, 0x25, 0x52, 0xb3, 0x89, 0x88, 0x8f, 0xc0, 0x7f, 0x1e, 0x46, 0x19, 0xdf,
-	0x83, 0xda, 0x70, 0x40, 0x21, 0xf8, 0xb2, 0x36, 0x1c, 0xf0, 0x1b, 0xe0, 0x3d, 0x55, 0xe7, 0x81,
-	0xd7, 0x63, 0xfd, 0x96, 0xc4, 0x25, 0xef, 0x42, 0xfd, 0x71, 0x5a, 0x26, 0x05, 0x85, 0xe1, 0x4b,
-	0x0d, 0xc4, 0x31, 0xb4, 0x70, 0xff, 0x93, 0x48, 0xc5, 0x33, 0x2e, 0xb4, 0xb3, 0x2a, 0x13, 0xa7,
-	0x28, 0x28, 0x95, 0xfa, 0xa0, 0x2e, 0xd4, 0xc9, 0x98, 0xdc, 0xb4, 0xa4, 0x06, 0xe2, 0x33, 0x00,
-	0xd4, 0xe6, 0xda, 0xcf, 0x3d, 0xa8, 0x13, 0xa2, 0xe8, 0x2f, 0x3b, 0xd2, 0xca, 0x2b, 0x3c, 0x8d,
-	0xa0, 0x49, 0x0b, 0x2c, 0xec, 0xca, 0x82, 0x39, 0x16, 0x28, 0xc5, 0x62, 0x0d, 0x4c, 0x22, 0x04,
-	0xf8, 0x6d, 0xd8, 0x91, 0xe9, 0xd2, 0xe6, 0x5c, 0x21, 0xf1, 0x25, 0xc0, 0xa7, 0x59, 0x5a, 0x2e,
-	0x28, 0x5d, 0xde, 0x87, 0x3a, 0xa1, 0x2a, 0x32, 0x6e, 0x23, 0x33, 0x87, 0x4a, 0x6d, 0xb0, 0xbd,
-	0x5c, 0x58, 0xd6, 0x71, 0x39, 0xa7, 0x23, 0x3c, 0x89, 0x4b, 0xf1, 0x1d, 0x83, 0xe6, 0x24, 0x8c,
-	0x57, 0xea, 0x49, 0x18, 0x53, 0xb8, 0x9e, 0xc4, 0xe5, 0xba, 0x1b, 0xcf, 0xb8, 0x79, 0x0b, 0x9a,
-	0x4f, 0xe2, 0x34, 0x2c, 0xd0, 0x18, 0x7d, 0x31, 0xb9, 0xc2, 0xfc, 0x01, 0xc0, 0x40, 0x4d, 0xa3,
-	0x79, 0x18, 0xa3, 0xd6, 0xa7, 0x4f, 0xf1, 0x86, 0x8d, 0xb3, 0xd2, 0x49, 0xc7, 0x48, 0x7c, 0x00,
-	0x8d, 0x0a, 0xe1, 0x79, 0x93, 0x30, 0x2e, 0x55, 0x15, 0x83, 0x06, 0x28, 0x1d, 0x4f, 0xc3, 0x58,
-	0x99, 0x28, 0x08, 0x88, 0x2f, 0x60, 0x57, 0xdf, 0x11, 0xec, 0xf6, 0xb1, 0x2a, 0x5e, 0xa1, 0x89,
-	0x5e, 0xe9, 0xde, 0x88, 0x9f, 0x19, 0xf8, 0xb8, 0x32, 0x0e, 0x98, 0x75, 0xc0, 0xc1, 0x3f, 0x39,
-	0x5f, 0xa8, 0xaa, 0xaa, 0xb4, 0xe6, 0x3d, 0x68, 0x8f, 0x0b, 0xbc, 0x56, 0x3a, 0x72, 0x7d, 0x9c,
-	0x2b, 0xc2, 0x7a, 0x0d, 0x93, 0x42, 0xab, 0x7d, 0x4a, 0x61, 0x85, 0xf9, 0x1d, 0x68, 0x1d, 0xa5,
-	0x69, 0xac, 0x95, 0xf5, 0x1e, 0xeb, 0x37, 0xa5, 0x15, 0xf0, 0x7d, 0x00, 0x53, 0xd9, 0x52, 0x05,
-	0x3b, 0x54, 0x6b, 0x47, 0x22, 0xee, 0x43, 0x03, 0x23, 0x7d, 0x16, 0x2e, 0x6c, 0x6e, 0xec, 0xba,
-	0xdc, 0xfe, 0x66, 0xd0, 0xf9, 0xbc, 0x54, 0xd9, 0xb9, 0x54, 0xdf, 0x94, 0x2a, 0x2f, 0xb0, 0xb6,
-	0x84, 0x4d, 0x93, 0x12, 0xc0, 0x76, 0x1c, 0xbf, 0x08, 0xb3, 0x99, 0xae, 0x94, 0x2f, 0x2b, 0x84,
-	0xb9, 0xda, 0x9a, 0xe7, 0x94, 0x6b, 0x53, 0xba, 0x22, 0x6a, 0x64, 0x35, 0x4f, 0x0b, 0x93, 0x4c,
-	0x85, 0x78, 0x1f, 0xfe, 0x7f, 0xfc, 0x72, 0x1a, 0x97, 0x33, 0x25, 0xd3, 0xa5, 0xde, 0xbd, 0x43,
-	0x06, 0x9b, 0x62, 0xfe, 0x36, 0xec, 0x55, 0x22, 0xc3, 0x88, 0x0d, 0x32, 0xdc, 0x90, 0xf2, 0x07,
-	0xd0, 0x39, 0x9e, 0x9f, 0xaa, 0xd9, 0x4c, 0xcd, 0x06, 0x61, 0x11, 0x06, 0x4d, 0xca, 0x7b, 0x83,
-	0x9f, 0xd6, 0x4c, 0xc4, 0xf7, 0x0c, 0x76, 0xab, 0xec, 0xf3, 0x45, 0x9a, 0xe4, 0x0a, 0x3f, 0xf1,
-	0x71, 0x96, 0x99, 0x4f, 0x7c, 0x9c, 0x65, 0xfc, 0x3e, 0x34, 0xa4, 0xca, 0xcb, 0xb8, 0x30, 0x5d,
-	0x72, 0xcb, 0x7a, 0x34, 0x7b, 0xcb, 0xb8, 0x90, 0xc6, 0x8a, 0x7f, 0x0c, 0x7b, 0x6b, 0x7d, 0xa8,
-	0xa9, 0xba, 0x7d, 0xf8, 0xa6, 0xdd, 0xb7, 0xa6, 0x97, 0x1b, 0xe6, 0xe2, 0x17, 0x0f, 0xda, 0x8e,
-	0xe7, 0x55, 0x93, 0x61, 0x7d, 0x76, 0xab, 0x26, 0xbb, 0x4b, 0x63, 0xe2, 0x0a, 0x92, 0x46, 0xb2,
-	0xe9, 0x00, 0x1b, 0x55, 0x6d, 0xc9, 0x46, 0x96, 0xc2, 0xbc, 0xeb, 0x28, 0x0c, 0x87, 0xce, 0x8b,
-	0x30, 0x39, 0x53, 0x33, 0x6a, 0xcb, 0xa6, 0x34, 0x90, 0x1f, 0x58, 0x56, 0xa0, 0xef, 0xb8, 0xc6,
-	0x35, 0x46, 0x23, 0x2d, 0x73, 0x68, 0xfa, 0x1a, 0x0e, 0xf0, 0x5b, 0x51, 0xbf, 0x68, 0xc4, 0x3f,
-	0x84, 0xb6, 0xa5, 0xaf, 0xbc, 0xfa, 0x44, 0x5d, 0xeb, 0xca, 0x2a, 0xa5, 0x6b, 0xc8, 0x3f, 0xd9,
-	0x9c, 0x28, 0x41, 0x8b, 0xa2, 0x08, 0xd6, 0x32, 0x77, 0xf4, 0x72, 0x73, 0x02, 0x3d, 0x70, 0x46,
-	0x5c, 0x00, 0xb4, 0xf9, 0xa6, 0xdd, 0xbc, 0x52, 0x49, 0x67, 0x10, 0xbe, 0xef, 0x4e, 0x81, 0xa0,
-	0x4d, 0x7b, 0xba, 0xeb, 0x95, 0xd3, 0x3a, 0xe9, 0xd8, 0x89, 0x3f, 0x18, 0xec, 0x0e, 0xe7, 0x8b,
-	0x34, 0x2b, 0x9c, 0x2b, 0x35, 0x4c, 0x66, 0xea, 0xa5, 0xb9, 0x52, 0x04, 0xb6, 0xcf, 0x0b, 0xa2,
-	0x36, 0xbc, 0x5a, 0x74, 0x95, 0x7c, 0xa9, 0x81, 0x53, 0x4e, 0x7f, 0xad, 0x9c, 0x77, 0xa0, 0xa5,
-	0x7b, 0x07, 0x55, 0x75, 0x52, 0x59, 0x81, 0x9e, 0xf7, 0x4b, 0x9a, 0xb1, 0x0d, 0x9a, 0xb1, 0x06,
-	0x22, 0x8d, 0x68, 0x33, 0x52, 0x36, 0x49, 0xe9, 0x48, 0x50, 0x7f, 0x12, 0xcd, 0x55, 0x5e, 0x84,
-	0xf3, 0x05, 0xde, 0x4b, 0xaf, 0xef, 0x49, 0x47, 0x22, 0xfe, 0x62, 0xc0, 0x75, 0x8e, 0x44, 0x3b,
-	0xff, 0x5d, 0xa2, 0xd7, 0x27, 0xb4, 0x1e, 0x76, 0xe3, 0x52, 0xd8, 0xb7, 0x61, 0x87, 0xe2, 0x31,
-	0x21, 0x57, 0x08, 0x59, 0xca, 0x72, 0xa4, 0xce, 0x97, 0x49, 0x57, 0xc4, 0x05, 0x74, 0x1c, 0x82,
-	0xc6, 0xee, 0x42, 0xdf, 0x6b, 0x32, 0x31, 0x81, 0xee, 0x49, 0x16, 0x26, 0x79, 0x1c, 0x16, 0x0a,
-	0x8f, 0x7b, 0x9d, 0xac, 0xb7, 0x3c, 0xde, 0xc4, 0x3b, 0x70, 0x6b, 0xc3, 0xaf, 0xe5, 0x22, 0x2c,
-	0x83, 0x47, 0x65, 0xc0, 0xa5, 0x18, 0xc3, 0xcd, 0x95, 0xe9, 0x70, 0xf0, 0x5a, 0x11, 0x5c, 0x76,
-	0xfa, 0xae, 0x93, 0x17, 0x39, 0xad, 0x8e, 0xdf, 0x16, 0xeb, 0x11, 0x04, 0x55, 0x6f, 0xeb, 0x97,
-	0x63, 0x15, 0xc1, 0x24, 0x52, 0x4b, 0xb4, 0x1f, 0x85, 0x73, 0x55, 0x05, 0x41, 0x6b, 0x94, 0x11,
-	0x17, 0xd7, 0xe8, 0xbd, 0x49, 0x6b, 0xf1, 0x03, 0x83, 0xee, 0x36, 0x27, 0xf4, 0xb8, 0x88, 0x55,
-	0xa8, 0xd9, 0xb7, 0x29, 0x35, 0xe0, 0x0f, 0xa1, 0xfe, 0x6d, 0xa4, 0x96, 0x86, 0x7d, 0x85, 0xbd,
-	0x80, 0x57, 0x45, 0x22, 0xf5, 0x06, 0x6c, 0x87, 0x47, 0xd3, 0x22, 0x4a, 0x13, 0xf3, 0x86, 0xd2,
-	0x08, 0xcf, 0x39, 0x8a, 0xd3, 0xe9, 0xd7, 0x44, 0x72, 0xbe, 0xd4, 0x40, 0xfc, 0xc4, 0x4c, 0x6e,
-	0xce, 0xf8, 0xfa, 0xd7, 0x0a, 0xeb, 0x1e, 0x36, 0xef, 0x10, 0xea, 0xe1, 0x40, 0xcf, 0x60, 0xfb,
-	0xd4, 0x30, 0x10, 0xe7, 0x3e, 0x2e, 0x27, 0x61, 0xac, 0x2f, 0x72, 0x4b, 0xae, 0xf0, 0xf5, 0x9d,
-	0x7f, 0x74, 0xe3, 0xd7, 0x8b, 0x7d, 0xf6, 0xdb, 0xc5, 0x3e, 0xfb, 0xfd, 0x62, 0x9f, 0xfd, 0xf8,
-	0xe7, 0xfe, 0xff, 0x4e, 0x77, 0xe8, 0xc7, 0xe1, 0xbd, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xd1,
-	0xe5, 0x55, 0xc9, 0x48, 0x0c, 0x00, 0x00,
+	// 1196 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xcd, 0x8e, 0x1b, 0x45,
+	0x10, 0xa6, 0x3d, 0xe3, 0xb5, 0x5d, 0xf6, 0x6e, 0x42, 0xc7, 0x09, 0x23, 0x14, 0x36, 0x56, 0x2b,
+	0x20, 0xc3, 0x61, 0xa3, 0x84, 0x10, 0xe5, 0x04, 0x64, 0xe3, 0x0d, 0x58, 0x51, 0x56, 0xa1, 0xbd,
+	0x32, 0x37, 0xa4, 0x59, 0xbb, 0xd9, 0x8c, 0x18, 0xcf, 0x98, 0xf9, 0xc1, 0xd9, 0x23, 0xcf, 0x00,
+	0x07, 0xc4, 0x13, 0xf0, 0x0e, 0xbc, 0x00, 0x47, 0x1e, 0x01, 0x96, 0x37, 0xe0, 0xca, 0x05, 0x55,
+	0xf5, 0xb4, 0xbb, 0xed, 0xf5, 0x2e, 0x51, 0xc4, 0xad, 0xbf, 0xaa, 0xea, 0xea, 0xfa, 0x6a, 0xaa,
+	0xab, 0x7a, 0xa0, 0x33, 0x2f, 0x8f, 0xe3, 0x68, 0xb2, 0x37, 0xcf, 0xd2, 0x22, 0xe5, 0xcd, 0x28,
+	0x29, 0x54, 0x96, 0x84, 0xb1, 0xc8, 0xc1, 0x93, 0xe9, 0x82, 0x07, 0xd0, 0x78, 0x9c, 0xc6, 0xe5,
+	0x2c, 0xc9, 0x03, 0xd6, 0xf3, 0xfa, 0xbe, 0x34, 0x90, 0x73, 0xf0, 0x9f, 0xaa, 0xd3, 0x3c, 0xf0,
+	0x7a, 0x5e, 0xbf, 0x25, 0x69, 0xcd, 0x6f, 0x43, 0xfd, 0x51, 0x51, 0x64, 0x79, 0x50, 0xeb, 0x79,
+	0xfd, 0xf6, 0xbd, 0x9d, 0x3d, 0xe3, 0x6e, 0x0f, 0xc5, 0x52, 0x2b, 0xd1, 0xa7, 0x4c, 0xc3, 0x2c,
+	0x4a, 0x4e, 0x02, 0xbf, 0xc7, 0xfa, 0x1d, 0x69, 0xa0, 0x78, 0x06, 0xad, 0x51, 0x74, 0x92, 0xa8,
+	0x29, 0x1e, 0x7d, 0x0b, 0xbc, 0xe7, 0x29, 0x1e, 0xcb, 0xfa, 0xed, 0x7b, 0xdb, 0xd6, 0x95, 0x4c,
+	0x17, 0x12, 0x35, 0x68, 0x70, 0xa8, 0x4e, 0x82, 0xda, 0x46, 0x83, 0x43, 0x75, 0x22, 0x1e, 0xc2,
+	0x8e, 0x4c, 0x17, 0xc3, 0xa9, 0x4a, 0x8a, 0xe8, 0xeb, 0x48, 0x65, 0x14, 0xb4, 0x4c, 0x17, 0x86,
+	0x0b, 0xad, 0x97, 0x44, 0x6a, 0x96, 0x88, 0xf8, 0x18, 0xfc, 0xe7, 0x61, 0x94, 0xf1, 0x1d, 0xa8,
+	0x0d, 0x07, 0x14, 0x82, 0x2f, 0x6b, 0xc3, 0x01, 0xbf, 0x0a, 0xde, 0x53, 0x75, 0x1a, 0x78, 0x3d,
+	0xd6, 0x6f, 0x49, 0x5c, 0xf2, 0x2e, 0xd4, 0x1f, 0xa7, 0x65, 0x52, 0x50, 0x18, 0xbe, 0xd4, 0x40,
+	0x1c, 0x40, 0x0b, 0xf7, 0x3f, 0x89, 0x54, 0x3c, 0xe5, 0x42, 0x3b, 0xab, 0x98, 0x38, 0x49, 0x41,
+	0xa9, 0xd4, 0x07, 0x75, 0xa1, 0x4e, 0xc6, 0xe4, 0xa6, 0x25, 0x35, 0x10, 0x9f, 0x03, 0xa0, 0x36,
+	0xd7, 0x7e, 0x6e, 0x43, 0x9d, 0x10, 0x45, 0x7f, 0xde, 0x91, 0x56, 0x5e, 0xe0, 0xe9, 0x1d, 0xa8,
+	0x0f, 0x93, 0xe2, 0xc1, 0x7d, 0x54, 0x8f, 0xc3, 0xb8, 0x54, 0x14, 0x8d, 0x27, 0x35, 0x10, 0x25,
+	0x34, 0xc9, 0x0e, 0xf3, 0xbe, 0x74, 0xc0, 0x1c, 0x07, 0x28, 0xc5, 0x5c, 0x0e, 0x0c, 0x4f, 0x02,
+	0xfc, 0x06, 0x6c, 0xc9, 0x74, 0x61, 0x53, 0x52, 0x21, 0xfe, 0xae, 0x39, 0xc5, 0x27, 0xce, 0x57,
+	0x6c, 0xa8, 0x14, 0x85, 0x39, 0xf6, 0x2b, 0x80, 0xcf, 0xb2, 0xb4, 0x9c, 0x53, 0xd2, 0x78, 0x1f,
+	0xea, 0x84, 0x2a, 0x7e, 0xdc, 0x6e, 0x32, 0xb1, 0x49, 0x6d, 0xb0, 0x39, 0xe9, 0xf8, 0x71, 0x46,
+	0xe5, 0x8c, 0x22, 0xf1, 0x24, 0x2e, 0xc5, 0xf7, 0x0c, 0x9a, 0xe3, 0x30, 0x5e, 0xaa, 0xc7, 0x61,
+	0x5c, 0xf1, 0xc6, 0xe5, 0xaa, 0x1b, 0xcf, 0xb8, 0x79, 0x1b, 0x9a, 0x4f, 0xe2, 0x34, 0x2c, 0xd0,
+	0x18, 0x7d, 0x31, 0xb9, 0xc4, 0xfc, 0x2e, 0xc0, 0x40, 0x4d, 0xa2, 0x59, 0x18, 0xa3, 0x56, 0x93,
+	0x7b, 0xd3, 0xc6, 0x59, 0xe9, 0xa4, 0x63, 0x24, 0x3e, 0x82, 0x46, 0x85, 0x36, 0xe7, 0x1e, 0xa5,
+	0xa3, 0x49, 0x18, 0x2b, 0x13, 0x05, 0x01, 0xf1, 0x25, 0x6c, 0xeb, 0x9b, 0x86, 0x77, 0x66, 0xa4,
+	0x8a, 0x57, 0x28, 0xc5, 0x57, 0xba, 0x7d, 0xe2, 0x17, 0x06, 0x3e, 0xae, 0x8c, 0x03, 0x66, 0x1d,
+	0x70, 0xf0, 0x8f, 0x4e, 0xe7, 0xaa, 0xca, 0x2a, 0xad, 0x79, 0x0f, 0xda, 0xa3, 0x02, 0x2f, 0xa7,
+	0x8e, 0x5c, 0x1f, 0xe7, 0x8a, 0x30, 0x5f, 0xc3, 0xa4, 0xb0, 0x9f, 0xdb, 0x93, 0x4b, 0xcc, 0x6f,
+	0x42, 0x6b, 0x3f, 0x4d, 0x63, 0xad, 0xac, 0xf7, 0x58, 0xbf, 0x29, 0xad, 0x80, 0xef, 0x02, 0x98,
+	0xcc, 0x96, 0x2a, 0xd8, 0xa2, 0x5c, 0x3b, 0x12, 0x71, 0x07, 0x1a, 0x18, 0xe9, 0xb3, 0x70, 0x6e,
+	0xb9, 0xb1, 0xcb, 0xb8, 0xfd, 0xc3, 0xa0, 0xf3, 0x45, 0xa9, 0xb2, 0x53, 0xa9, 0xbe, 0x2d, 0x55,
+	0x5e, 0x60, 0x6e, 0x09, 0x9b, 0x5a, 0x26, 0x80, 0x55, 0x3b, 0x7a, 0x11, 0x66, 0x53, 0x9d, 0x29,
+	0x5f, 0x56, 0x08, 0xb9, 0xda, 0x9c, 0xe7, 0xc4, 0xb5, 0x29, 0x5d, 0x11, 0xd5, 0xbb, 0x9a, 0xa5,
+	0x85, 0x21, 0x53, 0x21, 0xde, 0x87, 0x2b, 0x07, 0x2f, 0x27, 0x71, 0x39, 0x55, 0x32, 0x5d, 0xe8,
+	0xdd, 0x5b, 0x64, 0xb0, 0x2e, 0xe6, 0xef, 0xc1, 0x4e, 0x25, 0x32, 0x7d, 0xb5, 0x41, 0x86, 0x6b,
+	0x52, 0x7e, 0x17, 0x3a, 0x07, 0xb3, 0x63, 0x35, 0x9d, 0xaa, 0xe9, 0x20, 0x2c, 0xc2, 0xa0, 0x49,
+	0xbc, 0xd7, 0xba, 0xdc, 0x8a, 0x89, 0xf8, 0x81, 0xc1, 0x76, 0xc5, 0x3e, 0x9f, 0xa7, 0x49, 0xae,
+	0xf0, 0x13, 0x1f, 0x64, 0x99, 0xf9, 0xc4, 0x07, 0x59, 0xc6, 0xef, 0x40, 0x43, 0xaa, 0xbc, 0x8c,
+	0x0b, 0x53, 0x25, 0xd7, 0xad, 0x47, 0xb3, 0xb7, 0x8c, 0x0b, 0x69, 0xac, 0xf8, 0x27, 0xb0, 0xb3,
+	0x52, 0x87, 0xba, 0xe1, 0xb7, 0xef, 0xbd, 0x65, 0xf7, 0xad, 0xe8, 0xe5, 0x9a, 0xb9, 0xf8, 0xd5,
+	0x83, 0xb6, 0xe3, 0x79, 0x59, 0x64, 0x98, 0x9f, 0xed, 0xaa, 0xc8, 0x6e, 0xd1, 0xb0, 0xb9, 0xa0,
+	0xd5, 0x63, 0x4f, 0xea, 0x00, 0x3b, 0xac, 0xca, 0x92, 0x1d, 0xda, 0x46, 0xe8, 0x5d, 0xd6, 0x08,
+	0x71, 0x74, 0xbd, 0x08, 0x93, 0x13, 0x35, 0xa5, 0xb2, 0x6c, 0x4a, 0x03, 0xf9, 0x9e, 0xed, 0x0a,
+	0xf4, 0x1d, 0x57, 0x7a, 0x8d, 0xd1, 0x48, 0xdb, 0x39, 0x74, 0x97, 0x1b, 0x0e, 0xf0, 0x5b, 0x51,
+	0xbd, 0x68, 0xc4, 0x1f, 0x40, 0xdb, 0xb6, 0xaf, 0xbc, 0xfa, 0x44, 0x5d, 0xeb, 0xca, 0x2a, 0xa5,
+	0x6b, 0xc8, 0x3f, 0x5d, 0x9f, 0x4b, 0x41, 0x8b, 0xa2, 0x08, 0x56, 0x98, 0x3b, 0x7a, 0xb9, 0x3e,
+	0xc7, 0xee, 0x3a, 0x83, 0x32, 0x00, 0xda, 0x7c, 0xcd, 0x6e, 0x5e, 0xaa, 0xa4, 0x33, 0x4e, 0xef,
+	0xbb, 0xb3, 0x24, 0x68, 0xd3, 0x9e, 0xee, 0x6a, 0xe6, 0xb4, 0x4e, 0x3a, 0x76, 0xe2, 0x4f, 0x06,
+	0xdb, 0xc3, 0xd9, 0x3c, 0xcd, 0x0a, 0xe7, 0x4a, 0x0d, 0x93, 0xa9, 0x7a, 0x69, 0xae, 0x14, 0x81,
+	0xcd, 0x53, 0x87, 0x5a, 0x1b, 0x5e, 0x2d, 0xba, 0x4a, 0xbe, 0xd4, 0xc0, 0x49, 0xa7, 0xbf, 0x92,
+	0xce, 0x9b, 0xd0, 0xd2, 0xb5, 0x83, 0xaa, 0x3a, 0xa9, 0xac, 0x40, 0xbf, 0x1a, 0x16, 0x34, 0xa9,
+	0x1b, 0x34, 0xa9, 0x0d, 0xc4, 0x36, 0xa2, 0xcd, 0x48, 0xd9, 0x24, 0xa5, 0x23, 0x41, 0xfd, 0x51,
+	0x34, 0x53, 0x79, 0x11, 0xce, 0xe6, 0x78, 0x2f, 0xbd, 0xbe, 0x27, 0x1d, 0x89, 0xf8, 0x9b, 0x01,
+	0xd7, 0x1c, 0xa9, 0xed, 0xfc, 0x7f, 0x44, 0x2f, 0x27, 0xb4, 0x1a, 0x76, 0xe3, 0x5c, 0xd8, 0x37,
+	0x60, 0x8b, 0xe2, 0x31, 0x21, 0x57, 0x08, 0xbb, 0x94, 0xed, 0x91, 0x9a, 0x2f, 0x93, 0xae, 0x88,
+	0x0b, 0xe8, 0x38, 0x0d, 0x1a, 0xab, 0x0b, 0x7d, 0xaf, 0xc8, 0xc4, 0x18, 0xba, 0x47, 0x59, 0x98,
+	0xe4, 0x71, 0x58, 0x28, 0x3c, 0xee, 0x75, 0x58, 0x6f, 0x78, 0x02, 0x8a, 0xf7, 0xe1, 0xfa, 0x9a,
+	0x5f, 0xdb, 0x8b, 0x30, 0x0d, 0x1e, 0xa5, 0x01, 0x97, 0x62, 0x04, 0xd7, 0x96, 0xa6, 0xc3, 0xc1,
+	0x6b, 0x45, 0x70, 0xde, 0xe9, 0x07, 0x0e, 0x2f, 0x72, 0x5a, 0x1d, 0xbf, 0x29, 0xd6, 0x7d, 0x08,
+	0xaa, 0xda, 0xd6, 0xef, 0xcf, 0x2a, 0x82, 0x71, 0xa4, 0x16, 0x68, 0x7f, 0x18, 0xce, 0x54, 0x15,
+	0x04, 0xad, 0x51, 0x46, 0xbd, 0xb8, 0x46, 0xaf, 0x56, 0x5a, 0x8b, 0x1f, 0x19, 0x74, 0x37, 0x39,
+	0xa1, 0xc7, 0x45, 0xac, 0x42, 0xdd, 0x7d, 0x9b, 0x52, 0x03, 0xfe, 0x10, 0xea, 0xdf, 0x45, 0x6a,
+	0x61, 0xba, 0xaf, 0x70, 0x1e, 0x46, 0x17, 0x44, 0x22, 0xf5, 0x06, 0x2c, 0x87, 0x47, 0x93, 0x22,
+	0x4a, 0x13, 0xf3, 0xd4, 0xd2, 0x08, 0xcf, 0xd9, 0x8f, 0xd3, 0xc9, 0x37, 0xd4, 0xe4, 0x7c, 0xa9,
+	0x81, 0xf8, 0x99, 0x19, 0x6e, 0xce, 0xf8, 0xfa, 0xcf, 0x0c, 0xeb, 0x1a, 0x36, 0xef, 0x10, 0xaa,
+	0xe1, 0x40, 0xcf, 0x60, 0xfb, 0xd4, 0x30, 0x10, 0xe7, 0x3e, 0x2e, 0xc7, 0x61, 0xac, 0x2f, 0x72,
+	0x4b, 0x2e, 0xf1, 0xe5, 0x95, 0xbf, 0x7f, 0xf5, 0xb7, 0xb3, 0x5d, 0xf6, 0xfb, 0xd9, 0x2e, 0xfb,
+	0xe3, 0x6c, 0x97, 0xfd, 0xf4, 0xd7, 0xee, 0x1b, 0xc7, 0x5b, 0xf4, 0xfb, 0xf1, 0xe1, 0xbf, 0x01,
+	0x00, 0x00, 0xff, 0xff, 0x2b, 0xc8, 0xa6, 0x89, 0x8e, 0x0c, 0x00, 0x00,
 }

 func (m *Row) Marshal() (dAtA []byte, err error) {
@ -2168,6 +2225,38 @@ func (m *PairsField) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }

+func (m *Int64) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Int64) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Int64) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if m.Value != 0 {
+		i = encodeVarintPublic(dAtA, i, uint64(m.Value))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *FieldRow) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@ -2192,6 +2281,18 @@ func (m *FieldRow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i -= len(m.XXX_unrecognized)
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
+	if m.Value != nil {
+		{
+			size, err := m.Value.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPublic(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x22
+	}
 	if len(m.RowKey) > 0 {
 		i -= len(m.RowKey)
 		copy(dAtA[i:], m.RowKey)
@ -2597,20 +2698,20 @@ func (m *QueryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		dAtA[i] = 0x18
 	}
 	if len(m.Shards) > 0 {
-		dAtA10 := make([]byte, len(m.Shards)*10)
-		var j9 int
+		dAtA11 := make([]byte, len(m.Shards)*10)
+		var j10 int
 		for _, num := range m.Shards {
 			for num >= 1<<7 {
-				dAtA10[j9] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA11[j10] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j9++
+				j10++
 			}
-			dAtA10[j9] = uint8(num)
-			j9++
+			dAtA11[j10] = uint8(num)
+			j10++
 		}
-		i -= j9
-		copy(dAtA[i:], dAtA10[:j9])
-		i = encodeVarintPublic(dAtA, i, uint64(j9))
+		i -= j10
+		copy(dAtA[i:], dAtA11[:j10])
+		i = encodeVarintPublic(dAtA, i, uint64(j10))
 		i--
 		dAtA[i] = 0x12
 	}
@ -2761,20 +2862,20 @@ func (m *QueryResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		}
 	}
 	if len(m.RowIDs) > 0 {
-		dAtA15 := make([]byte, len(m.RowIDs)*10)
-		var j14 int
+		dAtA16 := make([]byte, len(m.RowIDs)*10)
+		var j15 int
 		for _, num := range m.RowIDs {
 			for num >= 1<<7 {
-				dAtA15[j14] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA16[j15] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j14++
+				j15++
 			}
-			dAtA15[j14] = uint8(num)
-			j14++
+			dAtA16[j15] = uint8(num)
+			j15++
 		}
-		i -= j14
-		copy(dAtA[i:], dAtA15[:j14])
-		i = encodeVarintPublic(dAtA, i, uint64(j14))
+		i -= j15
+		copy(dAtA[i:], dAtA16[:j15])
+		i = encodeVarintPublic(dAtA, i, uint64(j15))
 		i--
 		dAtA[i] = 0x3a
 	}
@ -2882,57 +2983,57 @@ func (m *ImportRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		}
 	}
 	if len(m.Timestamps) > 0 {
-		dAtA19 := make([]byte, len(m.Timestamps)*10)
-		var j18 int
+		dAtA20 := make([]byte, len(m.Timestamps)*10)
+		var j19 int
 		for _, num1 := range m.Timestamps {
 			num := uint64(num1)
 			for num >= 1<<7 {
-				dAtA19[j18] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA20[j19] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j18++
+				j19++
 			}
-			dAtA19[j18] = uint8(num)
-			j18++
+			dAtA20[j19] = uint8(num)
+			j19++
 		}
-		i -= j18
-		copy(dAtA[i:], dAtA19[:j18])
-		i = encodeVarintPublic(dAtA, i, uint64(j18))
+		i -= j19
+		copy(dAtA[i:], dAtA20[:j19])
+		i = encodeVarintPublic(dAtA, i, uint64(j19))
 		i--
 		dAtA[i] = 0x32
 	}
 	if len(m.ColumnIDs) > 0 {
-		dAtA21 := make([]byte, len(m.ColumnIDs)*10)
-		var j20 int
+		dAtA22 := make([]byte, len(m.ColumnIDs)*10)
+		var j21 int
 		for _, num := range m.ColumnIDs {
 			for num >= 1<<7 {
-				dAtA21[j20] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA22[j21] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j20++
+				j21++
 			}
-			dAtA21[j20] = uint8(num)
-			j20++
+			dAtA22[j21] = uint8(num)
+			j21++
 		}
-		i -= j20
-		copy(dAtA[i:], dAtA21[:j20])
-		i = encodeVarintPublic(dAtA, i, uint64(j20))
+		i -= j21
+		copy(dAtA[i:], dAtA22[:j21])
+		i = encodeVarintPublic(dAtA, i, uint64(j21))
 		i--
 		dAtA[i] = 0x2a
 	}
 	if len(m.RowIDs) > 0 {
-		dAtA23 := make([]byte, len(m.RowIDs)*10)
-		var j22 int
+		dAtA24 := make([]byte, len(m.RowIDs)*10)
+		var j23 int
 		for _, num := range m.RowIDs {
 			for num >= 1<<7 {
-				dAtA23[j22] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA24[j23] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j22++
+				j23++
 			}
-			dAtA23[j22] = uint8(num)
-			j22++
+			dAtA24[j23] = uint8(num)
+			j23++
 		}
-		i -= j22
-		copy(dAtA[i:], dAtA23[:j22])
-		i = encodeVarintPublic(dAtA, i, uint64(j22))
+		i -= j23
+		copy(dAtA[i:], dAtA24[:j23])
+		i = encodeVarintPublic(dAtA, i, uint64(j23))
 		i--
 		dAtA[i] = 0x22
 	}
@ -2993,9 +3094,9 @@ func (m *ImportValueRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	}
 	if len(m.FloatValues) > 0 {
 		for iNdEx := len(m.FloatValues) - 1; iNdEx >= 0; iNdEx-- {
-			f24 := math.Float64bits(float64(m.FloatValues[iNdEx]))
+			f25 := math.Float64bits(float64(m.FloatValues[iNdEx]))
 			i -= 8
-			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f24))
+			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f25))
 		}
 		i = encodeVarintPublic(dAtA, i, uint64(len(m.FloatValues)*8))
 		i--
@ -3011,39 +3112,39 @@ func (m *ImportValueRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		}
 	}
 	if len(m.Values) > 0 {
-		dAtA26 := make([]byte, len(m.Values)*10)
-		var j25 int
+		dAtA27 := make([]byte, len(m.Values)*10)
+		var j26 int
 		for _, num1 := range m.Values {
 			num := uint64(num1)
 			for num >= 1<<7 {
-				dAtA26[j25] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA27[j26] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j25++
+				j26++
 			}
-			dAtA26[j25] = uint8(num)
-			j25++
+			dAtA27[j26] = uint8(num)
+			j26++
 		}
-		i -= j25
-		copy(dAtA[i:], dAtA26[:j25])
-		i = encodeVarintPublic(dAtA, i, uint64(j25))
+		i -= j26
+		copy(dAtA[i:], dAtA27[:j26])
+		i = encodeVarintPublic(dAtA, i, uint64(j26))
 		i--
 		dAtA[i] = 0x32
 	}
 	if len(m.ColumnIDs) > 0 {
-		dAtA28 := make([]byte, len(m.ColumnIDs)*10)
-		var j27 int
+		dAtA29 := make([]byte, len(m.ColumnIDs)*10)
+		var j28 int
 		for _, num := range m.ColumnIDs {
 			for num >= 1<<7 {
-				dAtA28[j27] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA29[j28] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j27++
+				j28++
 			}
-			dAtA28[j27] = uint8(num)
-			j27++
+			dAtA29[j28] = uint8(num)
+			j28++
 		}
-		i -= j27
-		copy(dAtA[i:], dAtA28[:j27])
-		i = encodeVarintPublic(dAtA, i, uint64(j27))
+		i -= j28
+		copy(dAtA[i:], dAtA29[:j28])
+		i = encodeVarintPublic(dAtA, i, uint64(j28))
 		i--
 		dAtA[i] = 0x2a
 	}
@ -3144,20 +3245,20 @@ func (m *TranslateKeysResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.IDs) > 0 {
-		dAtA30 := make([]byte, len(m.IDs)*10)
-		var j29 int
+		dAtA31 := make([]byte, len(m.IDs)*10)
+		var j30 int
 		for _, num := range m.IDs {
 			for num >= 1<<7 {
-				dAtA30[j29] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA31[j30] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j29++
+				j30++
 			}
-			dAtA30[j29] = uint8(num)
-			j29++
+			dAtA31[j30] = uint8(num)
+			j30++
 		}
-		i -= j29
-		copy(dAtA[i:], dAtA30[:j29])
-		i = encodeVarintPublic(dAtA, i, uint64(j29))
+		i -= j30
+		copy(dAtA[i:], dAtA31[:j30])
+		i = encodeVarintPublic(dAtA, i, uint64(j30))
 		i--
 		dAtA[i] = 0x1a
 	}
@ -3189,20 +3290,20 @@ func (m *TranslateIDsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.IDs) > 0 {
-		dAtA32 := make([]byte, len(m.IDs)*10)
-		var j31 int
+		dAtA33 := make([]byte, len(m.IDs)*10)
+		var j32 int
 		for _, num := range m.IDs {
 			for num >= 1<<7 {
-				dAtA32[j31] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA33[j32] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j31++
+				j32++
 			}
-			dAtA32[j31] = uint8(num)
-			j31++
+			dAtA33[j32] = uint8(num)
+			j32++
 		}
-		i -= j31
-		copy(dAtA[i:], dAtA32[:j31])
-		i = encodeVarintPublic(dAtA, i, uint64(j31))
+		i -= j32
+		copy(dAtA[i:], dAtA33[:j32])
+		i = encodeVarintPublic(dAtA, i, uint64(j32))
 		i--
 		dAtA[i] = 0x1a
 	}
@ -3388,20 +3489,20 @@ func (m *ImportColumnAttrsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.ColumnIDs) > 0 {
-		dAtA34 := make([]byte, len(m.ColumnIDs)*10)
-		var j33 int
+		dAtA35 := make([]byte, len(m.ColumnIDs)*10)
+		var j34 int
 		for _, num := range m.ColumnIDs {
 			for num >= 1<<7 {
-				dAtA34[j33] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA35[j34] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j33++
+				j34++
 			}
-			dAtA34[j33] = uint8(num)
-			j33++
+			dAtA35[j34] = uint8(num)
+			j34++
 		}
-		i -= j33
-		copy(dAtA[i:], dAtA34[:j33])
-		i = encodeVarintPublic(dAtA, i, uint64(j33))
+		i -= j34
+		copy(dAtA[i:], dAtA35[:j34])
+		i = encodeVarintPublic(dAtA, i, uint64(j34))
 		i--
 		dAtA[i] = 0x2a
 	}
@ -3591,6 +3692,21 @@ func (m *PairsField) Size() (n int) {
 	return n
 }

+func (m *Int64) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Value != 0 {
+		n += 1 + sovPublic(uint64(m.Value))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
 func (m *FieldRow) Size() (n int) {
 	if m == nil {
 		return 0
@ -3608,6 +3724,10 @@ func (m *FieldRow) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPublic(uint64(l))
 	}
+	if m.Value != nil {
+		l = m.Value.Size()
+		n += 1 + l + sovPublic(uint64(l))
+	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
 	}
@ -5057,6 +5177,79 @@ func (m *PairsField) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *Int64) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowPublic
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Int64: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Int64: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
+			}
+			m.Value = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPublic
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Value |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipPublic(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *FieldRow) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
@ -5169,6 +5362,42 @@ func (m *FieldRow) Unmarshal(dAtA []byte) error {
 			}
 			m.RowKey = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPublic
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthPublic
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Value == nil {
+				m.Value = &Int64{}
+			}
+			if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipPublic(dAtA[iNdEx:])
--- a/internal/public.proto
+++ b/internal/public.proto
@ -35,10 +35,15 @@ message PairsField {
 	string Field = 2;
 }

-message FieldRow{
+message Int64 {
+	int64 Value = 1;
+}
+
+message FieldRow {
 	string Field = 1;
 	uint64 RowID = 2;
 	string RowKey = 3;
+	Int64 Value = 4;
 }

 message GroupCount{
--- a/server/grpc.go
+++ b/server/grpc.go
@ -738,6 +738,8 @@ func makeRows(resp pilosa.QueryResponse, logger logger.Logger) chan *pb.RowRespo
 						for _, fieldRow := range gc.Group {
 							if fieldRow.RowKey != "" {
 								ci = append(ci, &pb.ColumnInfo{Name: fieldRow.Field, Datatype: "string"})
+							} else if fieldRow.Value != nil {
+								ci = append(ci, &pb.ColumnInfo{Name: fieldRow.Field, Datatype: "int64"})
 							} else {
 								ci = append(ci, &pb.ColumnInfo{Name: fieldRow.Field, Datatype: "uint64"})
 							}
@ -753,8 +755,10 @@ func makeRows(resp pilosa.QueryResponse, logger logger.Logger) chan *pb.RowRespo
 					for _, fieldRow := range gc.Group {
 						if fieldRow.RowKey != "" {
 							rowResp.Columns = append(rowResp.Columns, &pb.ColumnResponse{ColumnVal: &pb.ColumnResponse_StringVal{StringVal: fieldRow.RowKey}})
+						} else if fieldRow.Value != nil {
+							rowResp.Columns = append(rowResp.Columns, &pb.ColumnResponse{ColumnVal: &pb.ColumnResponse_Int64Val{Int64Val: *fieldRow.Value}})
 						} else {
-							rowResp.Columns = append(rowResp.Columns, &pb.ColumnResponse{ColumnVal: &pb.ColumnResponse_Uint64Val{Uint64Val: uint64(fieldRow.RowID)}})
+							rowResp.Columns = append(rowResp.Columns, &pb.ColumnResponse{ColumnVal: &pb.ColumnResponse_Uint64Val{Uint64Val: fieldRow.RowID}})
 						}
 					}
 					rowResp.Columns = append(rowResp.Columns,
--- a/server/grpc_internal_test.go
+++ b/server/grpc_internal_test.go
@ -30,6 +30,7 @@ func TestGRPC(t *testing.T) {

 		type expColumn interface{}

+		va, vb := int64(-11), int64(-12)
 		tests := []struct {
 			result     interface{}
 			expHeaders []expHeader
@ -138,6 +139,13 @@ func TestGRPC(t *testing.T) {
 						},
 						Count: 456,
 					},
+					pilosa.GroupCount{
+						Group: []pilosa.FieldRow{
+							{Field: "va", Value: &va},
+							{Field: "vb", Value: &vb},
+						},
+						Count: 789,
+					},
 				},
 				[]expHeader{
 					{"a", "uint64"},
@ -148,6 +156,7 @@ func TestGRPC(t *testing.T) {
 				[][]expColumn{
 					{uint64(10), uint64(11), uint64(123), int64(0)},
 					{uint64(10), uint64(12), uint64(456), int64(0)},
+					{int64(va), int64(vb), uint64(789), int64(0)},
 				},
 			},
 			// []GroupCount (string)