diff --git a/api.go b/api.go
index 62002472e..68e282916 100644
--- a/api.go
+++ b/api.go
@@ -23,7 +23,9 @@ import (
 	"fmt"
 	"io"
 	"io/ioutil"
+	"math"
 	"net/url"
+	"sort"
 	"strconv"
 	"strings"
 	"sync"
@@ -890,10 +892,17 @@ func (api *API) FieldAttrDiff(ctx context.Context, indexName string, fieldName s
 	return attrs, nil
 }
 
-// ImportOptions holds the options for the API.Import method.
+// ImportOptions holds the options for the API.Import
+// method.
+//
+// TODO(2.0) we have entirely missed the point of functional options
+// by exporting this structure. If it needs to be exported for some
+// reason, we should consider not using functional options here which
+// just adds complexity.
 type ImportOptions struct {
 	Clear          bool
 	IgnoreKeyCheck bool
+	Presorted      bool
 }
 
 // ImportOption is a functional option type for API.Import.
@@ -917,6 +926,13 @@ func OptImportOptionsIgnoreKeyCheck(b bool) ImportOption {
 	}
 }
 
+func OptImportOptionsPresorted(b bool) ImportOption {
+	return func(o *ImportOptions) error {
+		o.Presorted = b
+		return nil
+	}
+}
+
 // Import bulk imports data into a particular index,field,shard.
 func (api *API) Import(ctx context.Context, req *ImportRequest, opts ...ImportOption) error {
 	span, _ := tracing.StartSpanFromContext(ctx, "API.Import")
@@ -1037,6 +1053,10 @@ func (api *API) ImportValue(ctx context.Context, req *ImportValueRequest, opts .
 		return errors.Wrap(err, "validating api method")
 	}
 
+	if err := req.Validate(); err != nil {
+		return errors.Wrap(err, "validating import value request")
+	}
+
 	// Set up import options.
 	options, err := setUpImportOptions(opts...)
 	if err != nil {
@@ -1060,57 +1080,93 @@ func (api *API) ImportValue(ctx context.Context, req *ImportValueRequest, opts .
 			if req.ColumnIDs, err = index.translateStore.TranslateKeys(req.ColumnKeys); err != nil {
 				return errors.Wrap(err, "translating columns")
 			}
-
-			// For translated data, map the columnIDs to shards. If
-			// this node does not own the shard, forward to the node that does.
-			m := make(map[uint64][]FieldValue)
-
-			for i, colID := range req.ColumnIDs {
-				shard := colID / ShardWidth
-				if _, ok := m[shard]; !ok {
-					m[shard] = make([]FieldValue, 0)
-				}
-				m[shard] = append(m[shard], FieldValue{
-					Value:    req.Values[i],
-					ColumnID: colID,
-				})
-			}
-
-			// Signal to the receiving nodes to ignore checking for key translation.
-			opts = append(opts, OptImportOptionsIgnoreKeyCheck(true))
-
-			var eg errgroup.Group
-			for shard, vals := range m {
-				// TODO: if local node owns this shard we don't need to go through the client
-				shard := shard
-				vals := vals
-				eg.Go(func() error {
-					return api.server.defaultClient.ImportValue(ctx, req.Index, req.Field, shard, vals, opts...)
-				})
-			}
-			return eg.Wait()
+			req.Shard = math.MaxUint64
 		}
 	}
 
-	// Validate shard ownership.
-	if err := api.validateShardOwnership(req.Index, req.Shard); err != nil {
-		return errors.Wrap(err, "validating shard ownership")
+	if !options.Presorted {
+		sort.Sort(req)
 	}
 
-	// Import columnIDs into existence field.
-	if !options.Clear {
-		if err := importExistenceColumns(index, req.ColumnIDs); err != nil {
-			api.server.logger.Printf("import existence error: index=%s, field=%s, shard=%d, columns=%d, err=%s", req.Index, req.Field, req.Shard, len(req.ColumnIDs), err)
-			return errors.Wrap(err, "importing existence columns")
+	// if we're importing into a specific shard
+	if req.Shard != math.MaxUint64 {
+		// Check that column IDs match the stated shard.
+		if s1, s2 := req.ColumnIDs[0]/ShardWidth, req.ColumnIDs[len(req.ColumnIDs)-1]/ShardWidth; s1 != s2 && s2 != req.Shard {
+			return errors.Errorf("shard %d specified, but import spans shards %d to %d", req.Shard, s1, s2)
+		}
+		// Validate shard ownership. TODO - we should forward to the
+		// correct node rather than barfing here.
+		if err := api.validateShardOwnership(req.Index, req.Shard); err != nil {
+			return errors.Wrap(err, "validating shard ownership")
+		}
+		// Import columnIDs into existence field.
+		if !options.Clear {
+			if err := importExistenceColumns(index, req.ColumnIDs); err != nil {
+				api.server.logger.Printf("import existence error: index=%s, field=%s, shard=%d, columns=%d, err=%s", req.Index, req.Field, req.Shard, len(req.ColumnIDs), err)
+				return errors.Wrap(err, "importing existence columns")
+			}
+		}
+
+		// Import into fragment.
+		if len(req.Values) > 0 {
+			err = field.importValue(req.ColumnIDs, req.Values, options)
+			if err != nil {
+				api.server.logger.Printf("import error: index=%s, field=%s, shard=%d, columns=%d, err=%s", req.Index, req.Field, req.Shard, len(req.ColumnIDs), err)
+			}
+		} else if len(req.FloatValues) > 0 {
+			err = field.importFloatValue(req.ColumnIDs, req.FloatValues, options)
+			if err != nil {
+				api.server.logger.Printf("import error: index=%s, field=%s, shard=%d, columns=%d, err=%s", req.Index, req.Field, req.Shard, len(req.ColumnIDs), err)
+			}
+		}
+
+		return errors.Wrap(err, "importing")
+	}
+
+	options.IgnoreKeyCheck = true
+	start := 0
+	shard := req.ColumnIDs[0] / ShardWidth
+	var eg errgroup.Group // TODO make this a pooled errgroup
+	for i, colID := range req.ColumnIDs {
+		if colID/ShardWidth != shard {
+			subreq := &ImportValueRequest{
+				Index:     req.Index,
+				Field:     req.Field,
+				Shard:     shard,
+				ColumnIDs: req.ColumnIDs[start:i],
+			}
+			if req.Values != nil {
+				subreq.Values = req.Values[start:i]
+			} else if req.FloatValues != nil {
+				subreq.FloatValues = req.FloatValues[start:i]
+			}
+
+			eg.Go(func() error {
+				return api.server.defaultClient.ImportValue2(ctx, subreq, options)
+			})
+			start = i
+			shard = colID / ShardWidth
 		}
 	}
-
-	// Import into fragment.
-	err = field.importValue(req.ColumnIDs, req.Values, options)
-	if err != nil {
-		api.server.logger.Printf("import error: index=%s, field=%s, shard=%d, columns=%d, err=%s", req.Index, req.Field, req.Shard, len(req.ColumnIDs), err)
+	subreq := &ImportValueRequest{
+		Index:     req.Index,
+		Field:     req.Field,
+		Shard:     shard,
+		ColumnIDs: req.ColumnIDs[start:],
 	}
-	return errors.Wrap(err, "importing")
+	if req.Values != nil {
+		subreq.Values = req.Values[start:]
+	} else if req.FloatValues != nil {
+		subreq.FloatValues = req.FloatValues[start:]
+	}
+	eg.Go(func() error {
+		// TODO we should elevate the logic for figuring out which
+		// node(s) to send to into API instead of having those details
+		// in the client implementation.
+		return api.server.defaultClient.ImportValue2(ctx, subreq, options)
+	})
+	return eg.Wait()
+
 }
 
 func importExistenceColumns(index *Index, columnIDs []uint64) error {
diff --git a/api_test.go b/api_test.go
index c019e8f6f..1084535af 100644
--- a/api_test.go
+++ b/api_test.go
@@ -258,6 +258,147 @@ func TestAPI_ImportValue(t *testing.T) {
 			t.Fatal(err)
 		}
 	})
+
+	t.Run("ValDecimalField", func(t *testing.T) {
+		ctx := context.Background()
+		index := "valdec"
+		field := "fdec"
+
+		_, err := m1.API.CreateIndex(ctx, index, pilosa.IndexOptions{})
+		if err != nil {
+			t.Fatalf("creating index: %v", err)
+		}
+		fld, err := m1.API.CreateField(ctx, index, field, pilosa.OptFieldTypeDecimal(1))
+		if err != nil {
+			t.Fatalf("creating field: %v", err)
+		}
+
+		// Generate some keyed records.
+		values := []float64{}
+		colIDs := []uint64{}
+		for i := 0; i < 10; i++ {
+			values = append(values, float64(i)+0.1)
+			colIDs = append(colIDs, uint64(i))
+		}
+
+		// Import data with keys to the coordinator (node0) and verify that it gets
+		// translated and forwarded to the owner of shard 0 (node1; because of offsetModHasher)
+		req := &pilosa.ImportValueRequest{
+			Index:       index,
+			Field:       field,
+			ColumnIDs:   colIDs,
+			FloatValues: values,
+		}
+		if err := m1.API.ImportValue(ctx, req); err != nil {
+			t.Fatal(err)
+		}
+
+		pql := fmt.Sprintf("Row(%s>60)", field)
+
+		// Query node0.
+		if res, err := m0.API.Query(ctx, &pilosa.QueryRequest{Index: index, Query: pql}); 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) {
+		ctx := context.Background()
+		index := "valdecneg"
+		field := "fdecneg"
+
+		_, err := m0.API.CreateIndex(ctx, index, pilosa.IndexOptions{})
+		if err != nil {
+			t.Fatalf("creating index: %v", err)
+		}
+		_, err = m0.API.CreateField(ctx, index, field, pilosa.OptFieldTypeDecimal(-1))
+		if err != nil {
+			t.Fatalf("creating field: %v", err)
+		}
+
+		// Generate some keyed records.
+		values := []float64{}
+		colIDs := []uint64{}
+		for i := 0; i < 10; i++ {
+			values = append(values, float64(i)*100+10)
+			colIDs = append(colIDs, uint64(i))
+		}
+
+		// Import data with keys to the coordinator (node0) and verify that it gets
+		// translated and forwarded to the owner of shard 0 (node1; because of offsetModHasher)
+		req := &pilosa.ImportValueRequest{
+			Index:       index,
+			Field:       field,
+			ColumnIDs:   colIDs,
+			FloatValues: values,
+		}
+		if err := m1.API.ImportValue(ctx, req); err != nil {
+			t.Fatal(err)
+		}
+
+		pql := fmt.Sprintf("Row(%s>60)", field)
+
+		// Query node0.
+		if res, err := m0.API.Query(ctx, &pilosa.QueryRequest{Index: index, Query: pql}); 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)
+		}
+
+	})
 }
 
 // offsetModHasher represents a simple, mod-based hashing offset by 1.
diff --git a/client.go b/client.go
index 3b815a6bd..f343f539e 100644
--- a/client.go
+++ b/client.go
@@ -59,6 +59,7 @@ type InternalClient interface {
 	EnsureFieldWithOptions(ctx context.Context, index, field string, opt FieldOptions) error
 	ImportValue(ctx context.Context, index, field string, shard uint64, vals []FieldValue, opts ...ImportOption) error
 	ImportValueK(ctx context.Context, index, field string, vals []FieldValue, opts ...ImportOption) error
+	ImportValue2(ctx context.Context, req *ImportValueRequest, options *ImportOptions) error
 	ExportCSV(ctx context.Context, index, field string, shard uint64, w io.Writer) error
 	CreateField(ctx context.Context, index, field string) error
 	CreateFieldWithOptions(ctx context.Context, index, field string, opt FieldOptions) error
@@ -129,6 +130,10 @@ func (n nopInternalClient) Import(ctx context.Context, index, field string, shar
 func (n nopInternalClient) ImportK(ctx context.Context, index, field string, bits []Bit, opts ...ImportOption) error {
 	return nil
 }
+func (n nopInternalClient) ImportValue2(ctx context.Context, req *ImportValueRequest, options *ImportOptions) error {
+	return nil
+}
+
 func (n nopInternalClient) ImportRoaring(ctx context.Context, uri *URI, index, field string, shard uint64, remote bool, req *ImportRoaringRequest) error {
 	return nil
 }
diff --git a/cmd/import.go b/cmd/import.go
index a84d719a9..8f013977c 100644
--- a/cmd/import.go
+++ b/cmd/import.go
@@ -53,7 +53,7 @@ omitted. If it is present then its format should be YYYY-MM-DDTHH:MM.
 	flags.StringVarP(&Importer.Field, "field", "f", "", "Field to import into.")
 	flags.BoolVar(&Importer.IndexOptions.Keys, "index-keys", false, "Specify keys=true when creating an index")
 	flags.BoolVar(&Importer.FieldOptions.Keys, "field-keys", false, "Specify keys=true when creating a field")
-	flags.StringVar(&Importer.FieldOptions.Type, "field-type", "", "Specify the field type when creating a field. One of: set, int, time, bool, mutex")
+	flags.StringVar(&Importer.FieldOptions.Type, "field-type", "", "Specify the field type when creating a field. One of: set, int, decimal, time, bool, mutex")
 	flags.Int64Var(&Importer.FieldOptions.Min, "field-min", 0, "Specify the minimum for an int field on creation")
 	flags.Int64Var(&Importer.FieldOptions.Max, "field-max", 0, "Specify the maximum for an int field on creation")
 	flags.StringVar(&Importer.FieldOptions.CacheType, "field-cache-type", pilosa.CacheTypeRanked, "Specify the cache type for a set field on creation. One of: none, lru, ranked")
diff --git a/ctl/import.go b/ctl/import.go
index d5b9da8be..0e33e8aca 100644
--- a/ctl/import.go
+++ b/ctl/import.go
@@ -20,6 +20,7 @@ import (
 	"fmt"
 	"io"
 	"log"
+	"math"
 	"os"
 	"sort"
 	"strconv"
@@ -102,11 +103,11 @@ func (cmd *ImportCommand) Run(ctx context.Context) error {
 		if cmd.FieldOptions.Type == "" {
 			// set the correct type for the field
 			if cmd.FieldOptions.TimeQuantum != "" {
-				cmd.FieldOptions.Type = "time"
+				cmd.FieldOptions.Type = pilosa.FieldTypeTime
 			} else if cmd.FieldOptions.Min != 0 || cmd.FieldOptions.Max != 0 {
-				cmd.FieldOptions.Type = "int"
+				cmd.FieldOptions.Type = pilosa.FieldTypeInt
 			} else {
-				cmd.FieldOptions.Type = "set"
+				cmd.FieldOptions.Type = pilosa.FieldTypeSet
 			}
 		}
 		err := cmd.ensureSchema(ctx)
@@ -163,8 +164,8 @@ func (cmd *ImportCommand) ensureSchema(ctx context.Context) error {
 // importPath parses a path into bits and imports it to the server.
 func (cmd *ImportCommand) importPath(ctx context.Context, fieldType string, useColumnKeys, useRowKeys bool, path string) error {
 	// If fieldType is `int`, treat the import data as values to be range-encoded.
-	if fieldType == pilosa.FieldTypeInt {
-		return cmd.bufferValues(ctx, useColumnKeys, path)
+	if fieldType == pilosa.FieldTypeInt || fieldType == pilosa.FieldTypeDecimal {
+		return cmd.bufferValues(ctx, useColumnKeys, fieldType == pilosa.FieldTypeDecimal, path)
 	}
 	return cmd.bufferBits(ctx, useColumnKeys, useRowKeys, path)
 }
@@ -285,9 +286,13 @@ func (cmd *ImportCommand) importBits(ctx context.Context, useColumnKeys, useRowK
 	return nil
 }
 
-// bufferValues buffers slices of FieldValues to be imported as a batch.
-func (cmd *ImportCommand) bufferValues(ctx context.Context, useColumnKeys bool, path string) error {
-	a := make([]pilosa.FieldValue, 0, cmd.BufferSize)
+// bufferValues buffers slices of record identifiers and values to be imported as a batch.
+func (cmd *ImportCommand) bufferValues(ctx context.Context, useColumnKeys, parseAsFloat bool, path string) error {
+	req := &pilosa.ImportValueRequest{
+		Index: cmd.Index,
+		Field: cmd.Field,
+		Shard: math.MaxUint64,
+	}
 
 	var r *csv.Reader
 
@@ -307,6 +312,7 @@ func (cmd *ImportCommand) bufferValues(ctx context.Context, useColumnKeys bool,
 
 	r.FieldsPerRecord = -1
 	rnum := 0
+
 	for {
 		rnum++
 
@@ -325,69 +331,44 @@ func (cmd *ImportCommand) bufferValues(ctx context.Context, useColumnKeys bool,
 			return fmt.Errorf("bad column count on row %d: col=%d", rnum, len(record))
 		}
 
-		var val pilosa.FieldValue
-
 		// Parse column id.
 		if useColumnKeys {
-			val.ColumnKey = record[0]
+			req.ColumnKeys = append(req.ColumnKeys, record[0])
+		} else if columnID, err := strconv.ParseUint(record[0], 10, 64); err == nil {
+			req.ColumnIDs = append(req.ColumnIDs, columnID)
+		} else if err != nil {
+			return fmt.Errorf("invalid column id on row %d: %q", rnum, record[0])
+		}
+
+		// Parse value.
+		if parseAsFloat {
+			value, err := strconv.ParseFloat(record[1], 64)
+			if err != nil {
+				return errors.Wrapf(err, "parseing value '%s' as float", record[1])
+			}
+			req.FloatValues = append(req.FloatValues, value)
 		} else {
-			if val.ColumnID, err = strconv.ParseUint(record[0], 10, 64); err != nil {
-				return fmt.Errorf("invalid column id on row %d: %q", rnum, record[0])
+			value, err := strconv.ParseInt(record[1], 10, 64)
+			if err != nil {
+				return errors.Wrapf(err, "invalid value on row %d: %q", rnum, record[1])
 			}
+			req.Values = append(req.Values, value)
 		}
 
-		// Parse FieldValue.
-		value, err := strconv.ParseInt(record[1], 10, 64)
-		if err != nil {
-			return fmt.Errorf("invalid value on row %d: %q", rnum, record[1])
-		}
-		val.Value = value
-
-		a = append(a, val)
-
-		// If we've reached the buffer size then import FieldValues.
-		if len(a) == cmd.BufferSize {
-			if err := cmd.importValues(ctx, useColumnKeys, a); err != nil {
-				return err
+		// If we've reached the buffer size then import the batch.
+		if len(req.ColumnKeys) == cmd.BufferSize || len(req.ColumnIDs) == cmd.BufferSize {
+			if err := cmd.client.ImportValue2(ctx, req, &pilosa.ImportOptions{}); err != nil {
+				return errors.Wrap(err, "importing values")
 			}
-			a = a[:0]
+			req.ColumnIDs = req.ColumnIDs[:0]
+			req.ColumnKeys = req.ColumnKeys[:0]
+			req.Values = req.Values[:0]
+			req.FloatValues = req.FloatValues[:0]
 		}
 	}
 
 	// If there are still values in the buffer then flush them.
-	return cmd.importValues(ctx, useColumnKeys, a)
-}
-
-// importValues sends batches of FieldValues to the server.
-func (cmd *ImportCommand) importValues(ctx context.Context, useColumnKeys bool, vals []pilosa.FieldValue) error {
-	logger := log.New(cmd.Stderr, "", log.LstdFlags)
-
-	// If keys are used, all values are sent to the primary translate store (i.e. coordinator).
-	if useColumnKeys {
-		logger.Printf("importing keyed values: n=%d", len(vals))
-		if err := cmd.client.ImportValueK(ctx, cmd.Index, cmd.Field, vals); err != nil {
-			return errors.Wrap(err, "importing keys")
-		}
-		return nil
-	}
-
-	// Group vals by shard.
-	logger.Printf("grouping %d vals", len(vals))
-	valsByShard := http.FieldValues(vals).GroupByShard()
-
-	// Parse path into FieldValues.
-	for shard, vals := range valsByShard {
-		if cmd.Sort {
-			sort.Sort(http.FieldValues(vals))
-		}
-
-		logger.Printf("importing shard: %d, n=%d", shard, len(vals))
-		if err := cmd.client.ImportValue(ctx, cmd.Index, cmd.Field, shard, vals, pilosa.OptImportOptionsClear(cmd.Clear)); err != nil {
-			return errors.Wrap(err, "importing values")
-		}
-	}
-
-	return nil
+	return errors.Wrap(cmd.client.ImportValue2(ctx, req, &pilosa.ImportOptions{}), "importing values")
 }
 
 func (cmd *ImportCommand) TLSHost() string {
diff --git a/diagnostics.go b/diagnostics.go
index 5176c7c89..b3ab1dd1f 100644
--- a/diagnostics.go
+++ b/diagnostics.go
@@ -233,7 +233,7 @@ func (d *diagnosticsCollector) EnrichWithSchemaProperties() {
 		numIndexes++
 		for _, field := range index.Fields() {
 			numFields++
-			if field.Type() == FieldTypeInt {
+			if field.Type() == FieldTypeInt || field.Type() == FieldTypeDecimal {
 				bsiFieldCount++
 			}
 			if field.TimeQuantum() != "" {
diff --git a/encoding/proto/proto.go b/encoding/proto/proto.go
index d525c8399..a44440057 100644
--- a/encoding/proto/proto.go
+++ b/encoding/proto/proto.go
@@ -369,12 +369,13 @@ func encodeImportRequest(m *pilosa.ImportRequest) *internal.ImportRequest {
 
 func encodeImportValueRequest(m *pilosa.ImportValueRequest) *internal.ImportValueRequest {
 	return &internal.ImportValueRequest{
-		Index:      m.Index,
-		Field:      m.Field,
-		Shard:      m.Shard,
-		ColumnIDs:  m.ColumnIDs,
-		ColumnKeys: m.ColumnKeys,
-		Values:     m.Values,
+		Index:       m.Index,
+		Field:       m.Field,
+		Shard:       m.Shard,
+		ColumnIDs:   m.ColumnIDs,
+		ColumnKeys:  m.ColumnKeys,
+		Values:      m.Values,
+		FloatValues: m.FloatValues,
 	}
 }
 
@@ -538,6 +539,7 @@ func encodeFieldOptions(o *pilosa.FieldOptions) *internal.FieldOptions {
 		Min:         o.Min,
 		Max:         o.Max,
 		Base:        o.Base,
+		Scale:       o.Scale,
 		BitDepth:    uint64(o.BitDepth),
 		TimeQuantum: string(o.TimeQuantum),
 		Keys:        o.Keys,
@@ -808,6 +810,7 @@ func decodeFieldOptions(options *internal.FieldOptions, m *pilosa.FieldOptions)
 	m.Min = options.Min
 	m.Max = options.Max
 	m.Base = options.Base
+	m.Scale = options.Scale
 	m.BitDepth = uint(options.BitDepth)
 	m.TimeQuantum = pilosa.TimeQuantum(options.TimeQuantum)
 	m.Keys = options.Keys
@@ -983,6 +986,7 @@ func decodeImportValueRequest(pb *internal.ImportValueRequest, m *pilosa.ImportV
 	m.ColumnIDs = pb.ColumnIDs
 	m.ColumnKeys = pb.ColumnKeys
 	m.Values = pb.Values
+	m.FloatValues = pb.FloatValues
 }
 
 func decodeImportRoaringRequest(pb *internal.ImportRoaringRequest, m *pilosa.ImportRoaringRequest) {
diff --git a/executor.go b/executor.go
index 1cb5dcf4e..928080ea6 100644
--- a/executor.go
+++ b/executor.go
@@ -944,7 +944,7 @@ func (e *executor) executeTopNShard(ctx context.Context, index string, c *pql.Ca
 	n, _, err := c.UintArg("n")
 	if err != nil {
 		return nil, fmt.Errorf("executeTopNShard: %v", err)
-	} else if f := e.Holder.Field(index, fieldName); f != nil && f.Type() == FieldTypeInt {
+	} else if f := e.Holder.Field(index, fieldName); f != nil && (f.Type() == FieldTypeInt || f.Type() == FieldTypeDecimal) {
 		return nil, fmt.Errorf("cannot compute TopN() on integer field: %q", fieldName)
 	}
 
@@ -2109,7 +2109,7 @@ func (e *executor) executeSet(ctx context.Context, index string, c *pql.Call, op
 	}
 
 	// Int field.
-	if f.Type() == FieldTypeInt {
+	if f.Type() == FieldTypeInt || f.Type() == FieldTypeDecimal {
 		// Read row value.
 		rowVal, ok, err := c.IntArg(fieldName)
 		if err != nil {
diff --git a/field.go b/field.go
index 38b364b67..548bab325 100644
--- a/field.go
+++ b/field.go
@@ -20,6 +20,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
+	"math"
 	"os"
 	"path/filepath"
 	"sort"
@@ -54,11 +55,12 @@ const (
 
 // Field types.
 const (
-	FieldTypeSet   = "set"
-	FieldTypeInt   = "int"
-	FieldTypeTime  = "time"
-	FieldTypeMutex = "mutex"
-	FieldTypeBool  = "bool"
+	FieldTypeSet     = "set"
+	FieldTypeInt     = "int"
+	FieldTypeTime    = "time"
+	FieldTypeMutex   = "mutex"
+	FieldTypeBool    = "bool"
+	FieldTypeDecimal = "decimal"
 )
 
 // Field represents a container for views.
@@ -155,6 +157,32 @@ func OptFieldTypeInt(min, max int64) FieldOption {
 	}
 }
 
+func OptFieldTypeDecimal(scale int64, minmax ...int64) FieldOption {
+	return func(fo *FieldOptions) error {
+		if fo.Type != "" {
+			return errors.Errorf("can't set field type to 'decimal', already set to: %s", fo.Type)
+		}
+		fo.Min = math.MinInt64
+		fo.Max = math.MaxInt64
+		if len(minmax) == 2 {
+			min, max := minmax[0], minmax[1]
+			if min > max {
+				return errors.Errorf("decimal field min cannot be greater than max, got %d, %d", min, max)
+			}
+			fo.Min = min
+			fo.Max = max
+		} else if len(minmax) > 2 {
+			return errors.Errorf("unknown extra parameters beyond min and max: %v", minmax)
+		} else if len(minmax) == 1 {
+			fo.Min = minmax[0]
+		}
+		fo.Type = FieldTypeDecimal
+		fo.Base = bsiBase(fo.Min, fo.Max)
+		fo.Scale = scale
+		return nil
+	}
+}
+
 // OptFieldTypeTime is a functional option on FieldOptions
 // used to specify the field as being type `time` and to
 // provide any respective configuration values.
@@ -550,6 +578,7 @@ func (f *Field) loadMeta() error {
 	f.options.Min = pb.Min
 	f.options.Max = pb.Max
 	f.options.Base = pb.Base
+	f.options.Scale = pb.Scale
 	f.options.BitDepth = uint(pb.BitDepth)
 	f.options.TimeQuantum = TimeQuantum(pb.TimeQuantum)
 	f.options.Keys = pb.Keys
@@ -609,13 +638,14 @@ func (f *Field) applyOptions(opt FieldOptions) error {
 		f.options.BitDepth = 0
 		f.options.TimeQuantum = ""
 		f.options.Keys = opt.Keys
-	case FieldTypeInt:
+	case FieldTypeInt, FieldTypeDecimal:
 		f.options.Type = opt.Type
 		f.options.CacheType = CacheTypeNone
 		f.options.CacheSize = 0
 		f.options.Min = opt.Min
 		f.options.Max = opt.Max
 		f.options.Base = opt.Base
+		f.options.Scale = opt.Scale
 		f.options.BitDepth = opt.BitDepth
 		f.options.TimeQuantum = ""
 		f.options.Keys = opt.Keys
@@ -627,6 +657,7 @@ func (f *Field) applyOptions(opt FieldOptions) error {
 			Min:      opt.Min,
 			Max:      opt.Max,
 			Base:     opt.Base,
+			Scale:    opt.Scale,
 			BitDepth: opt.BitDepth,
 		}
 		// Validate bsiGroup.
@@ -1051,6 +1082,21 @@ func (f *Field) allTimeViewsSortedByQuantum() (me []*view) {
 	return me
 }
 
+// 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
+}
+
 // 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)
@@ -1073,6 +1119,18 @@ 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.
@@ -1118,6 +1176,22 @@ func (f *Field) SetValue(columnID uint64, value int64) (changed bool, err error)
 	return view.setValue(columnID, bsig.BitDepth, baseValue)
 }
 
+// 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) {
@@ -1138,6 +1212,21 @@ func (f *Field) Sum(filter *Row, name string) (sum, count int64, err error) {
 	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.
+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) {
@@ -1158,6 +1247,21 @@ func (f *Field) Min(filter *Row, name string) (min, count int64, err error) {
 	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.
+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
+}
+
 // 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) {
@@ -1283,6 +1387,21 @@ func (f *Field) Import(rowIDs, columnIDs []uint64, timestamps []*time.Time, opts
 	return nil
 }
 
+func (f *Field) importFloatValue(columnIDs []uint64, values []float64, options *ImportOptions) error {
+	// convert values to int64 values based on scale
+	ivalues := make([]int64, len(values))
+	bsig := f.bsiGroup(f.name)
+	if bsig == nil {
+		return errors.Wrap(ErrBSIGroupNotFound, f.name)
+	}
+	mult := math.Pow10(int(bsig.Scale))
+	for i, fval := range values {
+		ivalues[i] = int64(fval * mult)
+	}
+	// then call importValue
+	return f.importValue(columnIDs, ivalues, options)
+}
+
 // importValue bulk imports range-encoded value data.
 func (f *Field) importValue(columnIDs []uint64, values []int64, options *ImportOptions) error {
 	viewName := viewBSIGroupPrefix + f.name
@@ -1419,6 +1538,7 @@ type FieldOptions struct {
 	BitDepth       uint        `json:"bitDepth,omitempty"`
 	Min            int64       `json:"min,omitempty"`
 	Max            int64       `json:"max,omitempty"`
+	Scale          int64       `json:"scale,omitempty"`
 	Keys           bool        `json:"keys"`
 	NoStandardView bool        `json:"noStandardView,omitempty"`
 	CacheSize      uint32      `json:"cacheSize,omitempty"`
@@ -1454,6 +1574,7 @@ func encodeFieldOptions(o *FieldOptions) *internal.FieldOptions {
 		CacheType:      o.CacheType,
 		CacheSize:      o.CacheSize,
 		Base:           o.Base,
+		Scale:          o.Scale,
 		BitDepth:       uint64(o.BitDepth),
 		Min:            o.Min,
 		Max:            o.Max,
@@ -1480,10 +1601,11 @@ func (o *FieldOptions) MarshalJSON() ([]byte, error) {
 			o.CacheSize,
 			o.Keys,
 		})
-	case FieldTypeInt:
+	case FieldTypeInt, FieldTypeDecimal:
 		return json.Marshal(struct {
 			Type     string `json:"type"`
 			Base     int64  `json:"base"`
+			Scale    int64  `json:"scale"`
 			BitDepth uint   `json:"bitDepth"`
 			Min      int64  `json:"min"`
 			Max      int64  `json:"max"`
@@ -1491,6 +1613,7 @@ func (o *FieldOptions) MarshalJSON() ([]byte, error) {
 		}{
 			o.Type,
 			o.Base,
+			o.Scale,
 			o.BitDepth,
 			o.Min,
 			o.Max,
@@ -1563,6 +1686,7 @@ type bsiGroup struct {
 	Min      int64  `json:"min,omitempty"`
 	Max      int64  `json:"max,omitempty"`
 	Base     int64  `json:"base,omitempty"`
+	Scale    int64  `json:"scale,omitempty"`
 	BitDepth uint   `json:"bitDepth,omitempty"`
 }
 
diff --git a/handler.go b/handler.go
index 6d1a8fc13..810043171 100644
--- a/handler.go
+++ b/handler.go
@@ -18,6 +18,7 @@ import (
 	"encoding/json"
 
 	"github.com/pilosa/pilosa/v2/tracing"
+	"github.com/pkg/errors"
 )
 
 // QueryRequest represent a request to process a query.
@@ -107,12 +108,39 @@ var NopHandler Handler = nopHandler{}
 // ImportValueRequest describes the import request structure
 // for a value (BSI) import.
 type ImportValueRequest struct {
-	Index      string
-	Field      string
-	Shard      uint64
-	ColumnIDs  []uint64
-	ColumnKeys []string
-	Values     []int64
+	Index string
+	Field string
+	// if Shard is MaxUint64 (an impossible shard value), this
+	// indicates that the column IDs may come from multiple shards.
+	Shard       uint64
+	ColumnIDs   []uint64
+	ColumnKeys  []string
+	Values      []int64
+	FloatValues []float64
+}
+
+func (ivr *ImportValueRequest) Len() int           { return len(ivr.ColumnIDs) }
+func (ivr *ImportValueRequest) Less(i, j int) bool { return ivr.ColumnIDs[i] < ivr.ColumnIDs[j] }
+func (ivr *ImportValueRequest) Swap(i, j int) {
+	ivr.ColumnIDs[i], ivr.ColumnIDs[j] = ivr.ColumnIDs[j], ivr.ColumnIDs[i]
+	if len(ivr.Values) > 0 {
+		ivr.Values[i], ivr.Values[j] = ivr.Values[j], ivr.Values[i]
+	} else if len(ivr.FloatValues) > 0 {
+		ivr.FloatValues[i], ivr.FloatValues[j] = ivr.FloatValues[j], ivr.FloatValues[i]
+	}
+}
+
+func (i *ImportValueRequest) Validate() error {
+	if i.Index == "" || i.Field == "" {
+		return errors.Errorf("index and field required, but got '%s' and '%s'", i.Index, i.Field)
+	}
+	if len(i.ColumnIDs) != 0 && len(i.ColumnKeys) != 0 {
+		return errors.Errorf("must pass either column ids or keys, but not both")
+	}
+	if len(i.Values) != 0 && len(i.FloatValues) != 0 {
+		return errors.Errorf("must pass ints or floats but not both")
+	}
+	return nil
 }
 
 // ImportRequest describes the import request structure
diff --git a/http/client.go b/http/client.go
index b23678c77..1b4a9e976 100644
--- a/http/client.go
+++ b/http/client.go
@@ -553,6 +553,35 @@ func (c *InternalClient) ImportValue(ctx context.Context, index, field string, s
 	return nil
 }
 
+// ImportValue2 is a simplified ImportValue method which just uses the
+// ImportValueRequest instead of splitting up ImportValue and
+// ImportValueK... it also supports importing float values. The idea
+// being that (assuming it works) this will become the default (and be
+// renamed) for 2.0, and we can deprecate the other methods.
+func (c *InternalClient) ImportValue2(ctx context.Context, req *pilosa.ImportValueRequest, options *pilosa.ImportOptions) error {
+	span, ctx := tracing.StartSpanFromContext(ctx, "InternalClient.NewImportValue")
+	defer span.Finish()
+
+	buf, err := c.serializer.Marshal(req)
+	if err != nil {
+		return errors.Errorf("marshal import request: %s", err)
+	}
+
+	// Retrieve a list of nodes that own the shard.
+	nodes, err := c.FragmentNodes(ctx, req.Index, req.Shard)
+	if err != nil {
+		return errors.Errorf("shard nodes: %s", err)
+	}
+
+	// Import to each node.
+	for _, node := range nodes {
+		if err := c.importNode(ctx, node, req.Index, req.Field, buf, options); err != nil {
+			return errors.Errorf("import node: host=%s, err=%s", node.URI, err)
+		}
+	}
+	return nil
+}
+
 // ImportValueK bulk imports keyed field values to a host.
 func (c *InternalClient) ImportValueK(ctx context.Context, index, field string, vals []pilosa.FieldValue, opts ...pilosa.ImportOption) error {
 	span, ctx := tracing.StartSpanFromContext(ctx, "InternalClient.ImportValueK")
@@ -791,18 +820,28 @@ func (c *InternalClient) CreateFieldWithOptions(ctx context.Context, index, fiel
 	}
 
 	// convert pilosa.FieldOptions to fieldOptions
+	//
+	// TODO this kind of sucks because it's one more place that needs
+	// changes when we change anything with field options (and there
+	// are a lot of places already). It's not clear to me that this is
+	// providing a lot of value, but I think this kind of validation
+	// should probably happen in the field anyway??
 	fieldOpt := fieldOptions{
 		Type: opt.Type,
 		Keys: &opt.Keys,
 	}
-	if fieldOpt.Type == "set" {
+	if fieldOpt.Type == pilosa.FieldTypeSet {
 		fieldOpt.CacheType = &opt.CacheType
 		fieldOpt.CacheSize = &opt.CacheSize
-	} else if fieldOpt.Type == "int" {
+	} else if fieldOpt.Type == pilosa.FieldTypeInt {
 		fieldOpt.Min = &opt.Min
 		fieldOpt.Max = &opt.Max
-	} else if fieldOpt.Type == "time" {
+	} else if fieldOpt.Type == pilosa.FieldTypeTime {
 		fieldOpt.TimeQuantum = &opt.TimeQuantum
+	} else if fieldOpt.Type == pilosa.FieldTypeDecimal {
+		fieldOpt.Min = &opt.Min
+		fieldOpt.Max = &opt.Max
+		fieldOpt.Scale = &opt.Scale
 	}
 
 	// TODO: remove buf completely? (depends on whether importer needs to create specific field types)
diff --git a/http/client_test.go b/http/client_test.go
index d61640d76..e7130c68f 100644
--- a/http/client_test.go
+++ b/http/client_test.go
@@ -998,6 +998,47 @@ func TestClient_FragmentBlocks(t *testing.T) {
 	}
 }
 
+func TestClient_CreateDecimalField(t *testing.T) {
+	cluster := test.MustRunCluster(t, 1)
+	defer cluster.Close()
+	cmd := cluster[0]
+
+	c := MustNewClient(cmd.URL(), http.GetHTTPClient(nil))
+
+	index := "cdf"
+	err := c.CreateIndex(context.Background(), index, pilosa.IndexOptions{})
+	if err != nil {
+		t.Fatalf("creating index: %v", err)
+	}
+	field := "dfield"
+	err = c.CreateFieldWithOptions(context.Background(), index, field, pilosa.FieldOptions{Type: pilosa.FieldTypeDecimal, Scale: 1, Min: -1000, Max: 1000})
+	if err != nil {
+		t.Fatalf("creating field: %v", err)
+	}
+
+	fld, err := cmd.API.Field(context.Background(), index, field)
+	if err != nil {
+		t.Fatalf("getting field: %v", err)
+	}
+	if fld.Options().Scale != 1 {
+		t.Fatalf("expected Scale 1, got: %+v", fld.Options())
+	}
+
+	err = c.ImportValue2(context.Background(), &pilosa.ImportValueRequest{Index: index, Field: field, ColumnIDs: []uint64{1, 2, 3}, Shard: 0, FloatValues: []float64{1.1, 2.2, 3.3}}, &pilosa.ImportOptions{})
+	if err != nil {
+		t.Fatalf("importing float values: %v", err)
+	}
+
+	resp, err := c.Query(context.Background(), index, &pilosa.QueryRequest{Index: index, Query: "Row(dfield>21)"})
+	if err != nil {
+		t.Fatalf("querying: %v", err)
+	}
+	if !reflect.DeepEqual(resp.Results[0].(*pilosa.Row).Columns(), []uint64{2, 3}) {
+		t.Fatalf("unexpected results: %v", resp.Results[0].(*pilosa.Row).Columns())
+	}
+
+}
+
 // Client represents a test wrapper for pilosa.Client.
 type Client struct {
 	*http.InternalClient
diff --git a/http/handler.go b/http/handler.go
index 7e508a43d..b9e905a81 100644
--- a/http/handler.go
+++ b/http/handler.go
@@ -776,7 +776,7 @@ func (h *Handler) handlePostField(w http.ResponseWriter, r *http.Request) {
 	switch req.Options.Type {
 	case pilosa.FieldTypeSet:
 		fos = append(fos, pilosa.OptFieldTypeSet(*req.Options.CacheType, *req.Options.CacheSize))
-	case pilosa.FieldTypeInt:
+	case pilosa.FieldTypeInt, pilosa.FieldTypeDecimal:
 		if req.Options.Min == nil {
 			min := int64(math.MinInt64)
 			req.Options.Min = &min
@@ -785,7 +785,15 @@ func (h *Handler) handlePostField(w http.ResponseWriter, r *http.Request) {
 			max := int64(math.MaxInt64)
 			req.Options.Max = &max
 		}
-		fos = append(fos, pilosa.OptFieldTypeInt(*req.Options.Min, *req.Options.Max))
+		if req.Options.Type == pilosa.FieldTypeDecimal {
+			scale := int64(0)
+			if req.Options.Scale != nil {
+				scale = *req.Options.Scale
+			}
+			fos = append(fos, pilosa.OptFieldTypeDecimal(scale, *req.Options.Min, *req.Options.Max))
+		} else {
+			fos = append(fos, pilosa.OptFieldTypeInt(*req.Options.Min, *req.Options.Max))
+		}
 	case pilosa.FieldTypeTime:
 		fos = append(fos, pilosa.OptFieldTypeTime(*req.Options.TimeQuantum, req.Options.NoStandardView))
 	case pilosa.FieldTypeMutex:
@@ -819,6 +827,7 @@ type fieldOptions struct {
 	CacheSize      *uint32             `json:"cacheSize,omitempty"`
 	Min            *int64              `json:"min,omitempty"`
 	Max            *int64              `json:"max,omitempty"`
+	Scale          *int64              `json:"scale,omitempty"`
 	TimeQuantum    *pilosa.TimeQuantum `json:"timeQuantum,omitempty"`
 	Keys           *bool               `json:"keys,omitempty"`
 	NoStandardView bool                `json:"noStandardView,omitempty"`
@@ -850,7 +859,7 @@ func (o *fieldOptions) validate() error {
 		} else if o.TimeQuantum != nil {
 			return pilosa.NewBadRequestError(errors.New("timeQuantum does not apply to field type set"))
 		}
-	case pilosa.FieldTypeInt:
+	case pilosa.FieldTypeInt, pilosa.FieldTypeDecimal:
 		if o.CacheType != nil {
 			return pilosa.NewBadRequestError(errors.New("cacheType does not apply to field type int"))
 		} else if o.CacheSize != nil {
@@ -1112,7 +1121,7 @@ func (h *Handler) handlePostImport(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// Unmarshal request based on field type.
-	if field.Type() == pilosa.FieldTypeInt {
+	if field.Type() == pilosa.FieldTypeInt || field.Type() == pilosa.FieldTypeDecimal {
 		// Field type: Int
 		// Marshal into request object.
 		req := &pilosa.ImportValueRequest{}
diff --git a/internal/private.pb.go b/internal/private.pb.go
index fc6c306e9..755370e74 100644
--- a/internal/private.pb.go
+++ b/internal/private.pb.go
@@ -1,48 +1,6 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: private.proto
 
-/*
-	Package internal is a generated protocol buffer package.
-
-	It is generated from these files:
-		private.proto
-
-	It has these top-level messages:
-		IndexMeta
-		FieldOptions
-		ImportResponse
-		BlockDataRequest
-		BlockDataResponse
-		Cache
-		MaxShards
-		CreateShardMessage
-		DeleteIndexMessage
-		CreateIndexMessage
-		CreateFieldMessage
-		DeleteFieldMessage
-		DeleteAvailableShardMessage
-		Field
-		Schema
-		Index
-		URI
-		Node
-		NodeStateMessage
-		NodeEventMessage
-		NodeStatus
-		IndexStatus
-		FieldStatus
-		ClusterStatus
-		BSIGroup
-		CreateViewMessage
-		DeleteViewMessage
-		ResizeInstruction
-		ResizeSource
-		ResizeInstructionComplete
-		SetCoordinatorMessage
-		UpdateCoordinatorMessage
-		Topology
-		RecalculateCaches
-*/
 package internal
 
 import proto "github.com/golang/protobuf/proto"
@@ -63,14 +21,45 @@ var _ = math.Inf
 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 
 type IndexMeta struct {
-	Keys           bool `protobuf:"varint,3,opt,name=Keys,proto3" json:"Keys,omitempty"`
-	TrackExistence bool `protobuf:"varint,4,opt,name=TrackExistence,proto3" json:"TrackExistence,omitempty"`
+	Keys                 bool     `protobuf:"varint,3,opt,name=Keys,proto3" json:"Keys,omitempty"`
+	TrackExistence       bool     `protobuf:"varint,4,opt,name=TrackExistence,proto3" json:"TrackExistence,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *IndexMeta) Reset()                    { *m = IndexMeta{} }
-func (m *IndexMeta) String() string            { return proto.CompactTextString(m) }
-func (*IndexMeta) ProtoMessage()               {}
-func (*IndexMeta) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{0} }
+func (m *IndexMeta) Reset()         { *m = IndexMeta{} }
+func (m *IndexMeta) String() string { return proto.CompactTextString(m) }
+func (*IndexMeta) ProtoMessage()    {}
+func (*IndexMeta) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{0}
+}
+func (m *IndexMeta) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *IndexMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_IndexMeta.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *IndexMeta) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_IndexMeta.Merge(dst, src)
+}
+func (m *IndexMeta) XXX_Size() int {
+	return m.Size()
+}
+func (m *IndexMeta) XXX_DiscardUnknown() {
+	xxx_messageInfo_IndexMeta.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IndexMeta proto.InternalMessageInfo
 
 func (m *IndexMeta) GetKeys() bool {
 	if m != nil {
@@ -87,22 +76,54 @@ func (m *IndexMeta) GetTrackExistence() bool {
 }
 
 type FieldOptions struct {
-	Type           string `protobuf:"bytes,8,opt,name=Type,proto3" json:"Type,omitempty"`
-	CacheType      string `protobuf:"bytes,3,opt,name=CacheType,proto3" json:"CacheType,omitempty"`
-	CacheSize      uint32 `protobuf:"varint,4,opt,name=CacheSize,proto3" json:"CacheSize,omitempty"`
-	TimeQuantum    string `protobuf:"bytes,5,opt,name=TimeQuantum,proto3" json:"TimeQuantum,omitempty"`
-	Keys           bool   `protobuf:"varint,11,opt,name=Keys,proto3" json:"Keys,omitempty"`
-	NoStandardView bool   `protobuf:"varint,12,opt,name=NoStandardView,proto3" json:"NoStandardView,omitempty"`
-	Base           int64  `protobuf:"varint,13,opt,name=Base,proto3" json:"Base,omitempty"`
-	BitDepth       uint64 `protobuf:"varint,14,opt,name=BitDepth,proto3" json:"BitDepth,omitempty"`
-	Min            int64  `protobuf:"varint,9,opt,name=Min,proto3" json:"Min,omitempty"`
-	Max            int64  `protobuf:"varint,10,opt,name=Max,proto3" json:"Max,omitempty"`
+	Type                 string   `protobuf:"bytes,8,opt,name=Type,proto3" json:"Type,omitempty"`
+	CacheType            string   `protobuf:"bytes,3,opt,name=CacheType,proto3" json:"CacheType,omitempty"`
+	CacheSize            uint32   `protobuf:"varint,4,opt,name=CacheSize,proto3" json:"CacheSize,omitempty"`
+	TimeQuantum          string   `protobuf:"bytes,5,opt,name=TimeQuantum,proto3" json:"TimeQuantum,omitempty"`
+	Min                  int64    `protobuf:"varint,9,opt,name=Min,proto3" json:"Min,omitempty"`
+	Max                  int64    `protobuf:"varint,10,opt,name=Max,proto3" json:"Max,omitempty"`
+	Keys                 bool     `protobuf:"varint,11,opt,name=Keys,proto3" json:"Keys,omitempty"`
+	NoStandardView       bool     `protobuf:"varint,12,opt,name=NoStandardView,proto3" json:"NoStandardView,omitempty"`
+	Base                 int64    `protobuf:"varint,13,opt,name=Base,proto3" json:"Base,omitempty"`
+	BitDepth             uint64   `protobuf:"varint,14,opt,name=BitDepth,proto3" json:"BitDepth,omitempty"`
+	Scale                int64    `protobuf:"varint,15,opt,name=Scale,proto3" json:"Scale,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *FieldOptions) Reset()                    { *m = FieldOptions{} }
-func (m *FieldOptions) String() string            { return proto.CompactTextString(m) }
-func (*FieldOptions) ProtoMessage()               {}
-func (*FieldOptions) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{1} }
+func (m *FieldOptions) Reset()         { *m = FieldOptions{} }
+func (m *FieldOptions) String() string { return proto.CompactTextString(m) }
+func (*FieldOptions) ProtoMessage()    {}
+func (*FieldOptions) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{1}
+}
+func (m *FieldOptions) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *FieldOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_FieldOptions.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *FieldOptions) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FieldOptions.Merge(dst, src)
+}
+func (m *FieldOptions) XXX_Size() int {
+	return m.Size()
+}
+func (m *FieldOptions) XXX_DiscardUnknown() {
+	xxx_messageInfo_FieldOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FieldOptions proto.InternalMessageInfo
 
 func (m *FieldOptions) GetType() string {
 	if m != nil {
@@ -132,6 +153,20 @@ func (m *FieldOptions) GetTimeQuantum() string {
 	return ""
 }
 
+func (m *FieldOptions) GetMin() int64 {
+	if m != nil {
+		return m.Min
+	}
+	return 0
+}
+
+func (m *FieldOptions) GetMax() int64 {
+	if m != nil {
+		return m.Max
+	}
+	return 0
+}
+
 func (m *FieldOptions) GetKeys() bool {
 	if m != nil {
 		return m.Keys
@@ -160,28 +195,52 @@ func (m *FieldOptions) GetBitDepth() uint64 {
 	return 0
 }
 
-func (m *FieldOptions) GetMin() int64 {
+func (m *FieldOptions) GetScale() int64 {
 	if m != nil {
-		return m.Min
-	}
-	return 0
-}
-
-func (m *FieldOptions) GetMax() int64 {
-	if m != nil {
-		return m.Max
+		return m.Scale
 	}
 	return 0
 }
 
 type ImportResponse struct {
-	Err string `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
+	Err                  string   `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *ImportResponse) Reset()                    { *m = ImportResponse{} }
-func (m *ImportResponse) String() string            { return proto.CompactTextString(m) }
-func (*ImportResponse) ProtoMessage()               {}
-func (*ImportResponse) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{2} }
+func (m *ImportResponse) Reset()         { *m = ImportResponse{} }
+func (m *ImportResponse) String() string { return proto.CompactTextString(m) }
+func (*ImportResponse) ProtoMessage()    {}
+func (*ImportResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{2}
+}
+func (m *ImportResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ImportResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ImportResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *ImportResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ImportResponse.Merge(dst, src)
+}
+func (m *ImportResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *ImportResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_ImportResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ImportResponse proto.InternalMessageInfo
 
 func (m *ImportResponse) GetErr() string {
 	if m != nil {
@@ -191,17 +250,48 @@ func (m *ImportResponse) GetErr() string {
 }
 
 type BlockDataRequest struct {
-	Index string `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
-	Field string `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
-	View  string `protobuf:"bytes,5,opt,name=View,proto3" json:"View,omitempty"`
-	Shard uint64 `protobuf:"varint,4,opt,name=Shard,proto3" json:"Shard,omitempty"`
-	Block uint64 `protobuf:"varint,3,opt,name=Block,proto3" json:"Block,omitempty"`
+	Index                string   `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
+	Field                string   `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
+	View                 string   `protobuf:"bytes,5,opt,name=View,proto3" json:"View,omitempty"`
+	Shard                uint64   `protobuf:"varint,4,opt,name=Shard,proto3" json:"Shard,omitempty"`
+	Block                uint64   `protobuf:"varint,3,opt,name=Block,proto3" json:"Block,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *BlockDataRequest) Reset()                    { *m = BlockDataRequest{} }
-func (m *BlockDataRequest) String() string            { return proto.CompactTextString(m) }
-func (*BlockDataRequest) ProtoMessage()               {}
-func (*BlockDataRequest) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{3} }
+func (m *BlockDataRequest) Reset()         { *m = BlockDataRequest{} }
+func (m *BlockDataRequest) String() string { return proto.CompactTextString(m) }
+func (*BlockDataRequest) ProtoMessage()    {}
+func (*BlockDataRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{3}
+}
+func (m *BlockDataRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *BlockDataRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_BlockDataRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *BlockDataRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BlockDataRequest.Merge(dst, src)
+}
+func (m *BlockDataRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *BlockDataRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_BlockDataRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BlockDataRequest proto.InternalMessageInfo
 
 func (m *BlockDataRequest) GetIndex() string {
 	if m != nil {
@@ -239,14 +329,45 @@ func (m *BlockDataRequest) GetBlock() uint64 {
 }
 
 type BlockDataResponse struct {
-	RowIDs    []uint64 `protobuf:"varint,1,rep,packed,name=RowIDs" json:"RowIDs,omitempty"`
-	ColumnIDs []uint64 `protobuf:"varint,2,rep,packed,name=ColumnIDs" json:"ColumnIDs,omitempty"`
+	RowIDs               []uint64 `protobuf:"varint,1,rep,packed,name=RowIDs" json:"RowIDs,omitempty"`
+	ColumnIDs            []uint64 `protobuf:"varint,2,rep,packed,name=ColumnIDs" json:"ColumnIDs,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *BlockDataResponse) Reset()                    { *m = BlockDataResponse{} }
-func (m *BlockDataResponse) String() string            { return proto.CompactTextString(m) }
-func (*BlockDataResponse) ProtoMessage()               {}
-func (*BlockDataResponse) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{4} }
+func (m *BlockDataResponse) Reset()         { *m = BlockDataResponse{} }
+func (m *BlockDataResponse) String() string { return proto.CompactTextString(m) }
+func (*BlockDataResponse) ProtoMessage()    {}
+func (*BlockDataResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{4}
+}
+func (m *BlockDataResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *BlockDataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_BlockDataResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *BlockDataResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BlockDataResponse.Merge(dst, src)
+}
+func (m *BlockDataResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *BlockDataResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_BlockDataResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BlockDataResponse proto.InternalMessageInfo
 
 func (m *BlockDataResponse) GetRowIDs() []uint64 {
 	if m != nil {
@@ -263,13 +384,44 @@ func (m *BlockDataResponse) GetColumnIDs() []uint64 {
 }
 
 type Cache struct {
-	IDs []uint64 `protobuf:"varint,1,rep,packed,name=IDs" json:"IDs,omitempty"`
+	IDs                  []uint64 `protobuf:"varint,1,rep,packed,name=IDs" json:"IDs,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *Cache) Reset()                    { *m = Cache{} }
-func (m *Cache) String() string            { return proto.CompactTextString(m) }
-func (*Cache) ProtoMessage()               {}
-func (*Cache) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{5} }
+func (m *Cache) Reset()         { *m = Cache{} }
+func (m *Cache) String() string { return proto.CompactTextString(m) }
+func (*Cache) ProtoMessage()    {}
+func (*Cache) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{5}
+}
+func (m *Cache) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Cache) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Cache.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *Cache) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Cache.Merge(dst, src)
+}
+func (m *Cache) XXX_Size() int {
+	return m.Size()
+}
+func (m *Cache) XXX_DiscardUnknown() {
+	xxx_messageInfo_Cache.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Cache proto.InternalMessageInfo
 
 func (m *Cache) GetIDs() []uint64 {
 	if m != nil {
@@ -279,13 +431,44 @@ func (m *Cache) GetIDs() []uint64 {
 }
 
 type MaxShards struct {
-	Standard map[string]uint64 `protobuf:"bytes,1,rep,name=Standard" json:"Standard,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	Standard             map[string]uint64 `protobuf:"bytes,1,rep,name=Standard" json:"Standard,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+	XXX_unrecognized     []byte            `json:"-"`
+	XXX_sizecache        int32             `json:"-"`
 }
 
-func (m *MaxShards) Reset()                    { *m = MaxShards{} }
-func (m *MaxShards) String() string            { return proto.CompactTextString(m) }
-func (*MaxShards) ProtoMessage()               {}
-func (*MaxShards) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{6} }
+func (m *MaxShards) Reset()         { *m = MaxShards{} }
+func (m *MaxShards) String() string { return proto.CompactTextString(m) }
+func (*MaxShards) ProtoMessage()    {}
+func (*MaxShards) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{6}
+}
+func (m *MaxShards) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MaxShards) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MaxShards.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *MaxShards) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MaxShards.Merge(dst, src)
+}
+func (m *MaxShards) XXX_Size() int {
+	return m.Size()
+}
+func (m *MaxShards) XXX_DiscardUnknown() {
+	xxx_messageInfo_MaxShards.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MaxShards proto.InternalMessageInfo
 
 func (m *MaxShards) GetStandard() map[string]uint64 {
 	if m != nil {
@@ -295,15 +478,46 @@ func (m *MaxShards) GetStandard() map[string]uint64 {
 }
 
 type CreateShardMessage struct {
-	Index string `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
-	Field string `protobuf:"bytes,3,opt,name=Field,proto3" json:"Field,omitempty"`
-	Shard uint64 `protobuf:"varint,2,opt,name=Shard,proto3" json:"Shard,omitempty"`
+	Index                string   `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
+	Field                string   `protobuf:"bytes,3,opt,name=Field,proto3" json:"Field,omitempty"`
+	Shard                uint64   `protobuf:"varint,2,opt,name=Shard,proto3" json:"Shard,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *CreateShardMessage) Reset()                    { *m = CreateShardMessage{} }
-func (m *CreateShardMessage) String() string            { return proto.CompactTextString(m) }
-func (*CreateShardMessage) ProtoMessage()               {}
-func (*CreateShardMessage) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{7} }
+func (m *CreateShardMessage) Reset()         { *m = CreateShardMessage{} }
+func (m *CreateShardMessage) String() string { return proto.CompactTextString(m) }
+func (*CreateShardMessage) ProtoMessage()    {}
+func (*CreateShardMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{7}
+}
+func (m *CreateShardMessage) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *CreateShardMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_CreateShardMessage.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *CreateShardMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CreateShardMessage.Merge(dst, src)
+}
+func (m *CreateShardMessage) XXX_Size() int {
+	return m.Size()
+}
+func (m *CreateShardMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_CreateShardMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CreateShardMessage proto.InternalMessageInfo
 
 func (m *CreateShardMessage) GetIndex() string {
 	if m != nil {
@@ -327,13 +541,44 @@ func (m *CreateShardMessage) GetShard() uint64 {
 }
 
 type DeleteIndexMessage struct {
-	Index string `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
+	Index                string   `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *DeleteIndexMessage) Reset()                    { *m = DeleteIndexMessage{} }
-func (m *DeleteIndexMessage) String() string            { return proto.CompactTextString(m) }
-func (*DeleteIndexMessage) ProtoMessage()               {}
-func (*DeleteIndexMessage) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{8} }
+func (m *DeleteIndexMessage) Reset()         { *m = DeleteIndexMessage{} }
+func (m *DeleteIndexMessage) String() string { return proto.CompactTextString(m) }
+func (*DeleteIndexMessage) ProtoMessage()    {}
+func (*DeleteIndexMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{8}
+}
+func (m *DeleteIndexMessage) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *DeleteIndexMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_DeleteIndexMessage.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *DeleteIndexMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DeleteIndexMessage.Merge(dst, src)
+}
+func (m *DeleteIndexMessage) XXX_Size() int {
+	return m.Size()
+}
+func (m *DeleteIndexMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_DeleteIndexMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DeleteIndexMessage proto.InternalMessageInfo
 
 func (m *DeleteIndexMessage) GetIndex() string {
 	if m != nil {
@@ -343,14 +588,45 @@ func (m *DeleteIndexMessage) GetIndex() string {
 }
 
 type CreateIndexMessage struct {
-	Index string     `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
-	Meta  *IndexMeta `protobuf:"bytes,2,opt,name=Meta" json:"Meta,omitempty"`
+	Index                string     `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
+	Meta                 *IndexMeta `protobuf:"bytes,2,opt,name=Meta" json:"Meta,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
+	XXX_unrecognized     []byte     `json:"-"`
+	XXX_sizecache        int32      `json:"-"`
 }
 
-func (m *CreateIndexMessage) Reset()                    { *m = CreateIndexMessage{} }
-func (m *CreateIndexMessage) String() string            { return proto.CompactTextString(m) }
-func (*CreateIndexMessage) ProtoMessage()               {}
-func (*CreateIndexMessage) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{9} }
+func (m *CreateIndexMessage) Reset()         { *m = CreateIndexMessage{} }
+func (m *CreateIndexMessage) String() string { return proto.CompactTextString(m) }
+func (*CreateIndexMessage) ProtoMessage()    {}
+func (*CreateIndexMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{9}
+}
+func (m *CreateIndexMessage) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *CreateIndexMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_CreateIndexMessage.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *CreateIndexMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CreateIndexMessage.Merge(dst, src)
+}
+func (m *CreateIndexMessage) XXX_Size() int {
+	return m.Size()
+}
+func (m *CreateIndexMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_CreateIndexMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CreateIndexMessage proto.InternalMessageInfo
 
 func (m *CreateIndexMessage) GetIndex() string {
 	if m != nil {
@@ -367,15 +643,46 @@ func (m *CreateIndexMessage) GetMeta() *IndexMeta {
 }
 
 type CreateFieldMessage struct {
-	Index string        `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
-	Field string        `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
-	Meta  *FieldOptions `protobuf:"bytes,3,opt,name=Meta" json:"Meta,omitempty"`
+	Index                string        `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
+	Field                string        `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
+	Meta                 *FieldOptions `protobuf:"bytes,3,opt,name=Meta" json:"Meta,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
+	XXX_unrecognized     []byte        `json:"-"`
+	XXX_sizecache        int32         `json:"-"`
 }
 
-func (m *CreateFieldMessage) Reset()                    { *m = CreateFieldMessage{} }
-func (m *CreateFieldMessage) String() string            { return proto.CompactTextString(m) }
-func (*CreateFieldMessage) ProtoMessage()               {}
-func (*CreateFieldMessage) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{10} }
+func (m *CreateFieldMessage) Reset()         { *m = CreateFieldMessage{} }
+func (m *CreateFieldMessage) String() string { return proto.CompactTextString(m) }
+func (*CreateFieldMessage) ProtoMessage()    {}
+func (*CreateFieldMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{10}
+}
+func (m *CreateFieldMessage) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *CreateFieldMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_CreateFieldMessage.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *CreateFieldMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CreateFieldMessage.Merge(dst, src)
+}
+func (m *CreateFieldMessage) XXX_Size() int {
+	return m.Size()
+}
+func (m *CreateFieldMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_CreateFieldMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CreateFieldMessage proto.InternalMessageInfo
 
 func (m *CreateFieldMessage) GetIndex() string {
 	if m != nil {
@@ -399,14 +706,45 @@ func (m *CreateFieldMessage) GetMeta() *FieldOptions {
 }
 
 type DeleteFieldMessage struct {
-	Index string `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
-	Field string `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
+	Index                string   `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
+	Field                string   `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *DeleteFieldMessage) Reset()                    { *m = DeleteFieldMessage{} }
-func (m *DeleteFieldMessage) String() string            { return proto.CompactTextString(m) }
-func (*DeleteFieldMessage) ProtoMessage()               {}
-func (*DeleteFieldMessage) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{11} }
+func (m *DeleteFieldMessage) Reset()         { *m = DeleteFieldMessage{} }
+func (m *DeleteFieldMessage) String() string { return proto.CompactTextString(m) }
+func (*DeleteFieldMessage) ProtoMessage()    {}
+func (*DeleteFieldMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{11}
+}
+func (m *DeleteFieldMessage) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *DeleteFieldMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_DeleteFieldMessage.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *DeleteFieldMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DeleteFieldMessage.Merge(dst, src)
+}
+func (m *DeleteFieldMessage) XXX_Size() int {
+	return m.Size()
+}
+func (m *DeleteFieldMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_DeleteFieldMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DeleteFieldMessage proto.InternalMessageInfo
 
 func (m *DeleteFieldMessage) GetIndex() string {
 	if m != nil {
@@ -423,17 +761,46 @@ func (m *DeleteFieldMessage) GetField() string {
 }
 
 type DeleteAvailableShardMessage struct {
-	Index   string `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
-	Field   string `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
-	ShardID uint64 `protobuf:"varint,3,opt,name=ShardID,proto3" json:"ShardID,omitempty"`
+	Index                string   `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
+	Field                string   `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
+	ShardID              uint64   `protobuf:"varint,3,opt,name=ShardID,proto3" json:"ShardID,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *DeleteAvailableShardMessage) Reset()         { *m = DeleteAvailableShardMessage{} }
 func (m *DeleteAvailableShardMessage) String() string { return proto.CompactTextString(m) }
 func (*DeleteAvailableShardMessage) ProtoMessage()    {}
 func (*DeleteAvailableShardMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptorPrivate, []int{12}
+	return fileDescriptor_private_b229d027a4642df7, []int{12}
 }
+func (m *DeleteAvailableShardMessage) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *DeleteAvailableShardMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_DeleteAvailableShardMessage.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *DeleteAvailableShardMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DeleteAvailableShardMessage.Merge(dst, src)
+}
+func (m *DeleteAvailableShardMessage) XXX_Size() int {
+	return m.Size()
+}
+func (m *DeleteAvailableShardMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_DeleteAvailableShardMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DeleteAvailableShardMessage proto.InternalMessageInfo
 
 func (m *DeleteAvailableShardMessage) GetIndex() string {
 	if m != nil {
@@ -457,15 +824,46 @@ func (m *DeleteAvailableShardMessage) GetShardID() uint64 {
 }
 
 type Field struct {
-	Name  string        `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
-	Meta  *FieldOptions `protobuf:"bytes,2,opt,name=Meta" json:"Meta,omitempty"`
-	Views []string      `protobuf:"bytes,3,rep,name=Views" json:"Views,omitempty"`
+	Name                 string        `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
+	Meta                 *FieldOptions `protobuf:"bytes,2,opt,name=Meta" json:"Meta,omitempty"`
+	Views                []string      `protobuf:"bytes,3,rep,name=Views" json:"Views,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
+	XXX_unrecognized     []byte        `json:"-"`
+	XXX_sizecache        int32         `json:"-"`
 }
 
-func (m *Field) Reset()                    { *m = Field{} }
-func (m *Field) String() string            { return proto.CompactTextString(m) }
-func (*Field) ProtoMessage()               {}
-func (*Field) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{13} }
+func (m *Field) Reset()         { *m = Field{} }
+func (m *Field) String() string { return proto.CompactTextString(m) }
+func (*Field) ProtoMessage()    {}
+func (*Field) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{13}
+}
+func (m *Field) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Field) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Field.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *Field) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Field.Merge(dst, src)
+}
+func (m *Field) XXX_Size() int {
+	return m.Size()
+}
+func (m *Field) XXX_DiscardUnknown() {
+	xxx_messageInfo_Field.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Field proto.InternalMessageInfo
 
 func (m *Field) GetName() string {
 	if m != nil {
@@ -489,13 +887,44 @@ func (m *Field) GetViews() []string {
 }
 
 type Schema struct {
-	Indexes []*Index `protobuf:"bytes,1,rep,name=Indexes" json:"Indexes,omitempty"`
+	Indexes              []*Index `protobuf:"bytes,1,rep,name=Indexes" json:"Indexes,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *Schema) Reset()                    { *m = Schema{} }
-func (m *Schema) String() string            { return proto.CompactTextString(m) }
-func (*Schema) ProtoMessage()               {}
-func (*Schema) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{14} }
+func (m *Schema) Reset()         { *m = Schema{} }
+func (m *Schema) String() string { return proto.CompactTextString(m) }
+func (*Schema) ProtoMessage()    {}
+func (*Schema) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{14}
+}
+func (m *Schema) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Schema) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Schema.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *Schema) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Schema.Merge(dst, src)
+}
+func (m *Schema) XXX_Size() int {
+	return m.Size()
+}
+func (m *Schema) XXX_DiscardUnknown() {
+	xxx_messageInfo_Schema.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Schema proto.InternalMessageInfo
 
 func (m *Schema) GetIndexes() []*Index {
 	if m != nil {
@@ -505,14 +934,45 @@ func (m *Schema) GetIndexes() []*Index {
 }
 
 type Index struct {
-	Name   string   `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
-	Fields []*Field `protobuf:"bytes,4,rep,name=Fields" json:"Fields,omitempty"`
+	Name                 string   `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
+	Fields               []*Field `protobuf:"bytes,4,rep,name=Fields" json:"Fields,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *Index) Reset()                    { *m = Index{} }
-func (m *Index) String() string            { return proto.CompactTextString(m) }
-func (*Index) ProtoMessage()               {}
-func (*Index) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{15} }
+func (m *Index) Reset()         { *m = Index{} }
+func (m *Index) String() string { return proto.CompactTextString(m) }
+func (*Index) ProtoMessage()    {}
+func (*Index) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{15}
+}
+func (m *Index) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Index) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Index.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *Index) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Index.Merge(dst, src)
+}
+func (m *Index) XXX_Size() int {
+	return m.Size()
+}
+func (m *Index) XXX_DiscardUnknown() {
+	xxx_messageInfo_Index.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Index proto.InternalMessageInfo
 
 func (m *Index) GetName() string {
 	if m != nil {
@@ -529,15 +989,46 @@ func (m *Index) GetFields() []*Field {
 }
 
 type URI struct {
-	Scheme string `protobuf:"bytes,1,opt,name=Scheme,proto3" json:"Scheme,omitempty"`
-	Host   string `protobuf:"bytes,2,opt,name=Host,proto3" json:"Host,omitempty"`
-	Port   uint32 `protobuf:"varint,3,opt,name=Port,proto3" json:"Port,omitempty"`
+	Scheme               string   `protobuf:"bytes,1,opt,name=Scheme,proto3" json:"Scheme,omitempty"`
+	Host                 string   `protobuf:"bytes,2,opt,name=Host,proto3" json:"Host,omitempty"`
+	Port                 uint32   `protobuf:"varint,3,opt,name=Port,proto3" json:"Port,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *URI) Reset()                    { *m = URI{} }
-func (m *URI) String() string            { return proto.CompactTextString(m) }
-func (*URI) ProtoMessage()               {}
-func (*URI) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{16} }
+func (m *URI) Reset()         { *m = URI{} }
+func (m *URI) String() string { return proto.CompactTextString(m) }
+func (*URI) ProtoMessage()    {}
+func (*URI) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{16}
+}
+func (m *URI) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *URI) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_URI.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *URI) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_URI.Merge(dst, src)
+}
+func (m *URI) XXX_Size() int {
+	return m.Size()
+}
+func (m *URI) XXX_DiscardUnknown() {
+	xxx_messageInfo_URI.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_URI proto.InternalMessageInfo
 
 func (m *URI) GetScheme() string {
 	if m != nil {
@@ -561,16 +1052,47 @@ func (m *URI) GetPort() uint32 {
 }
 
 type Node struct {
-	ID            string `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
-	URI           *URI   `protobuf:"bytes,2,opt,name=URI" json:"URI,omitempty"`
-	IsCoordinator bool   `protobuf:"varint,3,opt,name=IsCoordinator,proto3" json:"IsCoordinator,omitempty"`
-	State         string `protobuf:"bytes,4,opt,name=State,proto3" json:"State,omitempty"`
+	ID                   string   `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
+	URI                  *URI     `protobuf:"bytes,2,opt,name=URI" json:"URI,omitempty"`
+	IsCoordinator        bool     `protobuf:"varint,3,opt,name=IsCoordinator,proto3" json:"IsCoordinator,omitempty"`
+	State                string   `protobuf:"bytes,4,opt,name=State,proto3" json:"State,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *Node) Reset()                    { *m = Node{} }
-func (m *Node) String() string            { return proto.CompactTextString(m) }
-func (*Node) ProtoMessage()               {}
-func (*Node) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{17} }
+func (m *Node) Reset()         { *m = Node{} }
+func (m *Node) String() string { return proto.CompactTextString(m) }
+func (*Node) ProtoMessage()    {}
+func (*Node) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{17}
+}
+func (m *Node) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Node) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Node.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *Node) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Node.Merge(dst, src)
+}
+func (m *Node) XXX_Size() int {
+	return m.Size()
+}
+func (m *Node) XXX_DiscardUnknown() {
+	xxx_messageInfo_Node.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Node proto.InternalMessageInfo
 
 func (m *Node) GetID() string {
 	if m != nil {
@@ -601,14 +1123,45 @@ func (m *Node) GetState() string {
 }
 
 type NodeStateMessage struct {
-	NodeID string `protobuf:"bytes,1,opt,name=NodeID,proto3" json:"NodeID,omitempty"`
-	State  string `protobuf:"bytes,2,opt,name=State,proto3" json:"State,omitempty"`
+	NodeID               string   `protobuf:"bytes,1,opt,name=NodeID,proto3" json:"NodeID,omitempty"`
+	State                string   `protobuf:"bytes,2,opt,name=State,proto3" json:"State,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *NodeStateMessage) Reset()                    { *m = NodeStateMessage{} }
-func (m *NodeStateMessage) String() string            { return proto.CompactTextString(m) }
-func (*NodeStateMessage) ProtoMessage()               {}
-func (*NodeStateMessage) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{18} }
+func (m *NodeStateMessage) Reset()         { *m = NodeStateMessage{} }
+func (m *NodeStateMessage) String() string { return proto.CompactTextString(m) }
+func (*NodeStateMessage) ProtoMessage()    {}
+func (*NodeStateMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{18}
+}
+func (m *NodeStateMessage) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *NodeStateMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_NodeStateMessage.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *NodeStateMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_NodeStateMessage.Merge(dst, src)
+}
+func (m *NodeStateMessage) XXX_Size() int {
+	return m.Size()
+}
+func (m *NodeStateMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_NodeStateMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_NodeStateMessage proto.InternalMessageInfo
 
 func (m *NodeStateMessage) GetNodeID() string {
 	if m != nil {
@@ -625,14 +1178,45 @@ func (m *NodeStateMessage) GetState() string {
 }
 
 type NodeEventMessage struct {
-	Event uint32 `protobuf:"varint,1,opt,name=Event,proto3" json:"Event,omitempty"`
-	Node  *Node  `protobuf:"bytes,2,opt,name=Node" json:"Node,omitempty"`
+	Event                uint32   `protobuf:"varint,1,opt,name=Event,proto3" json:"Event,omitempty"`
+	Node                 *Node    `protobuf:"bytes,2,opt,name=Node" json:"Node,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *NodeEventMessage) Reset()                    { *m = NodeEventMessage{} }
-func (m *NodeEventMessage) String() string            { return proto.CompactTextString(m) }
-func (*NodeEventMessage) ProtoMessage()               {}
-func (*NodeEventMessage) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{19} }
+func (m *NodeEventMessage) Reset()         { *m = NodeEventMessage{} }
+func (m *NodeEventMessage) String() string { return proto.CompactTextString(m) }
+func (*NodeEventMessage) ProtoMessage()    {}
+func (*NodeEventMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{19}
+}
+func (m *NodeEventMessage) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *NodeEventMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_NodeEventMessage.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *NodeEventMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_NodeEventMessage.Merge(dst, src)
+}
+func (m *NodeEventMessage) XXX_Size() int {
+	return m.Size()
+}
+func (m *NodeEventMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_NodeEventMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_NodeEventMessage proto.InternalMessageInfo
 
 func (m *NodeEventMessage) GetEvent() uint32 {
 	if m != nil {
@@ -649,15 +1233,46 @@ func (m *NodeEventMessage) GetNode() *Node {
 }
 
 type NodeStatus struct {
-	Node    *Node          `protobuf:"bytes,1,opt,name=Node" json:"Node,omitempty"`
-	Schema  *Schema        `protobuf:"bytes,3,opt,name=Schema" json:"Schema,omitempty"`
-	Indexes []*IndexStatus `protobuf:"bytes,4,rep,name=Indexes" json:"Indexes,omitempty"`
+	Node                 *Node          `protobuf:"bytes,1,opt,name=Node" json:"Node,omitempty"`
+	Schema               *Schema        `protobuf:"bytes,3,opt,name=Schema" json:"Schema,omitempty"`
+	Indexes              []*IndexStatus `protobuf:"bytes,4,rep,name=Indexes" json:"Indexes,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
+	XXX_unrecognized     []byte         `json:"-"`
+	XXX_sizecache        int32          `json:"-"`
 }
 
-func (m *NodeStatus) Reset()                    { *m = NodeStatus{} }
-func (m *NodeStatus) String() string            { return proto.CompactTextString(m) }
-func (*NodeStatus) ProtoMessage()               {}
-func (*NodeStatus) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{20} }
+func (m *NodeStatus) Reset()         { *m = NodeStatus{} }
+func (m *NodeStatus) String() string { return proto.CompactTextString(m) }
+func (*NodeStatus) ProtoMessage()    {}
+func (*NodeStatus) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{20}
+}
+func (m *NodeStatus) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *NodeStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_NodeStatus.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *NodeStatus) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_NodeStatus.Merge(dst, src)
+}
+func (m *NodeStatus) XXX_Size() int {
+	return m.Size()
+}
+func (m *NodeStatus) XXX_DiscardUnknown() {
+	xxx_messageInfo_NodeStatus.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_NodeStatus proto.InternalMessageInfo
 
 func (m *NodeStatus) GetNode() *Node {
 	if m != nil {
@@ -681,14 +1296,45 @@ func (m *NodeStatus) GetIndexes() []*IndexStatus {
 }
 
 type IndexStatus struct {
-	Name   string         `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
-	Fields []*FieldStatus `protobuf:"bytes,2,rep,name=Fields" json:"Fields,omitempty"`
+	Name                 string         `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
+	Fields               []*FieldStatus `protobuf:"bytes,2,rep,name=Fields" json:"Fields,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
+	XXX_unrecognized     []byte         `json:"-"`
+	XXX_sizecache        int32          `json:"-"`
 }
 
-func (m *IndexStatus) Reset()                    { *m = IndexStatus{} }
-func (m *IndexStatus) String() string            { return proto.CompactTextString(m) }
-func (*IndexStatus) ProtoMessage()               {}
-func (*IndexStatus) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{21} }
+func (m *IndexStatus) Reset()         { *m = IndexStatus{} }
+func (m *IndexStatus) String() string { return proto.CompactTextString(m) }
+func (*IndexStatus) ProtoMessage()    {}
+func (*IndexStatus) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{21}
+}
+func (m *IndexStatus) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *IndexStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_IndexStatus.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *IndexStatus) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_IndexStatus.Merge(dst, src)
+}
+func (m *IndexStatus) XXX_Size() int {
+	return m.Size()
+}
+func (m *IndexStatus) XXX_DiscardUnknown() {
+	xxx_messageInfo_IndexStatus.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IndexStatus proto.InternalMessageInfo
 
 func (m *IndexStatus) GetName() string {
 	if m != nil {
@@ -705,14 +1351,45 @@ func (m *IndexStatus) GetFields() []*FieldStatus {
 }
 
 type FieldStatus struct {
-	Name            string   `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
-	AvailableShards []uint64 `protobuf:"varint,2,rep,packed,name=AvailableShards" json:"AvailableShards,omitempty"`
+	Name                 string   `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
+	AvailableShards      []uint64 `protobuf:"varint,2,rep,packed,name=AvailableShards" json:"AvailableShards,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *FieldStatus) Reset()                    { *m = FieldStatus{} }
-func (m *FieldStatus) String() string            { return proto.CompactTextString(m) }
-func (*FieldStatus) ProtoMessage()               {}
-func (*FieldStatus) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{22} }
+func (m *FieldStatus) Reset()         { *m = FieldStatus{} }
+func (m *FieldStatus) String() string { return proto.CompactTextString(m) }
+func (*FieldStatus) ProtoMessage()    {}
+func (*FieldStatus) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{22}
+}
+func (m *FieldStatus) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *FieldStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_FieldStatus.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *FieldStatus) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FieldStatus.Merge(dst, src)
+}
+func (m *FieldStatus) XXX_Size() int {
+	return m.Size()
+}
+func (m *FieldStatus) XXX_DiscardUnknown() {
+	xxx_messageInfo_FieldStatus.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FieldStatus proto.InternalMessageInfo
 
 func (m *FieldStatus) GetName() string {
 	if m != nil {
@@ -729,15 +1406,46 @@ func (m *FieldStatus) GetAvailableShards() []uint64 {
 }
 
 type ClusterStatus struct {
-	ClusterID string  `protobuf:"bytes,1,opt,name=ClusterID,proto3" json:"ClusterID,omitempty"`
-	State     string  `protobuf:"bytes,2,opt,name=State,proto3" json:"State,omitempty"`
-	Nodes     []*Node `protobuf:"bytes,3,rep,name=Nodes" json:"Nodes,omitempty"`
+	ClusterID            string   `protobuf:"bytes,1,opt,name=ClusterID,proto3" json:"ClusterID,omitempty"`
+	State                string   `protobuf:"bytes,2,opt,name=State,proto3" json:"State,omitempty"`
+	Nodes                []*Node  `protobuf:"bytes,3,rep,name=Nodes" json:"Nodes,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *ClusterStatus) Reset()                    { *m = ClusterStatus{} }
-func (m *ClusterStatus) String() string            { return proto.CompactTextString(m) }
-func (*ClusterStatus) ProtoMessage()               {}
-func (*ClusterStatus) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{23} }
+func (m *ClusterStatus) Reset()         { *m = ClusterStatus{} }
+func (m *ClusterStatus) String() string { return proto.CompactTextString(m) }
+func (*ClusterStatus) ProtoMessage()    {}
+func (*ClusterStatus) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{23}
+}
+func (m *ClusterStatus) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ClusterStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ClusterStatus.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *ClusterStatus) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ClusterStatus.Merge(dst, src)
+}
+func (m *ClusterStatus) XXX_Size() int {
+	return m.Size()
+}
+func (m *ClusterStatus) XXX_DiscardUnknown() {
+	xxx_messageInfo_ClusterStatus.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ClusterStatus proto.InternalMessageInfo
 
 func (m *ClusterStatus) GetClusterID() string {
 	if m != nil {
@@ -761,16 +1469,47 @@ func (m *ClusterStatus) GetNodes() []*Node {
 }
 
 type BSIGroup struct {
-	Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
-	Type string `protobuf:"bytes,2,opt,name=Type,proto3" json:"Type,omitempty"`
-	Min  int64  `protobuf:"varint,3,opt,name=Min,proto3" json:"Min,omitempty"`
-	Max  int64  `protobuf:"varint,4,opt,name=Max,proto3" json:"Max,omitempty"`
+	Name                 string   `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
+	Type                 string   `protobuf:"bytes,2,opt,name=Type,proto3" json:"Type,omitempty"`
+	Min                  int64    `protobuf:"varint,3,opt,name=Min,proto3" json:"Min,omitempty"`
+	Max                  int64    `protobuf:"varint,4,opt,name=Max,proto3" json:"Max,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *BSIGroup) Reset()                    { *m = BSIGroup{} }
-func (m *BSIGroup) String() string            { return proto.CompactTextString(m) }
-func (*BSIGroup) ProtoMessage()               {}
-func (*BSIGroup) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{24} }
+func (m *BSIGroup) Reset()         { *m = BSIGroup{} }
+func (m *BSIGroup) String() string { return proto.CompactTextString(m) }
+func (*BSIGroup) ProtoMessage()    {}
+func (*BSIGroup) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{24}
+}
+func (m *BSIGroup) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *BSIGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_BSIGroup.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *BSIGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BSIGroup.Merge(dst, src)
+}
+func (m *BSIGroup) XXX_Size() int {
+	return m.Size()
+}
+func (m *BSIGroup) XXX_DiscardUnknown() {
+	xxx_messageInfo_BSIGroup.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BSIGroup proto.InternalMessageInfo
 
 func (m *BSIGroup) GetName() string {
 	if m != nil {
@@ -801,15 +1540,46 @@ func (m *BSIGroup) GetMax() int64 {
 }
 
 type CreateViewMessage struct {
-	Index string `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
-	Field string `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
-	View  string `protobuf:"bytes,3,opt,name=View,proto3" json:"View,omitempty"`
+	Index                string   `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
+	Field                string   `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
+	View                 string   `protobuf:"bytes,3,opt,name=View,proto3" json:"View,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *CreateViewMessage) Reset()                    { *m = CreateViewMessage{} }
-func (m *CreateViewMessage) String() string            { return proto.CompactTextString(m) }
-func (*CreateViewMessage) ProtoMessage()               {}
-func (*CreateViewMessage) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{25} }
+func (m *CreateViewMessage) Reset()         { *m = CreateViewMessage{} }
+func (m *CreateViewMessage) String() string { return proto.CompactTextString(m) }
+func (*CreateViewMessage) ProtoMessage()    {}
+func (*CreateViewMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{25}
+}
+func (m *CreateViewMessage) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *CreateViewMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_CreateViewMessage.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *CreateViewMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CreateViewMessage.Merge(dst, src)
+}
+func (m *CreateViewMessage) XXX_Size() int {
+	return m.Size()
+}
+func (m *CreateViewMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_CreateViewMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CreateViewMessage proto.InternalMessageInfo
 
 func (m *CreateViewMessage) GetIndex() string {
 	if m != nil {
@@ -833,15 +1603,46 @@ func (m *CreateViewMessage) GetView() string {
 }
 
 type DeleteViewMessage struct {
-	Index string `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
-	Field string `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
-	View  string `protobuf:"bytes,3,opt,name=View,proto3" json:"View,omitempty"`
+	Index                string   `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
+	Field                string   `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
+	View                 string   `protobuf:"bytes,3,opt,name=View,proto3" json:"View,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *DeleteViewMessage) Reset()                    { *m = DeleteViewMessage{} }
-func (m *DeleteViewMessage) String() string            { return proto.CompactTextString(m) }
-func (*DeleteViewMessage) ProtoMessage()               {}
-func (*DeleteViewMessage) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{26} }
+func (m *DeleteViewMessage) Reset()         { *m = DeleteViewMessage{} }
+func (m *DeleteViewMessage) String() string { return proto.CompactTextString(m) }
+func (*DeleteViewMessage) ProtoMessage()    {}
+func (*DeleteViewMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{26}
+}
+func (m *DeleteViewMessage) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *DeleteViewMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_DeleteViewMessage.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *DeleteViewMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DeleteViewMessage.Merge(dst, src)
+}
+func (m *DeleteViewMessage) XXX_Size() int {
+	return m.Size()
+}
+func (m *DeleteViewMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_DeleteViewMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DeleteViewMessage proto.InternalMessageInfo
 
 func (m *DeleteViewMessage) GetIndex() string {
 	if m != nil {
@@ -865,18 +1666,49 @@ func (m *DeleteViewMessage) GetView() string {
 }
 
 type ResizeInstruction struct {
-	JobID         int64           `protobuf:"varint,1,opt,name=JobID,proto3" json:"JobID,omitempty"`
-	Node          *Node           `protobuf:"bytes,2,opt,name=Node" json:"Node,omitempty"`
-	Coordinator   *Node           `protobuf:"bytes,3,opt,name=Coordinator" json:"Coordinator,omitempty"`
-	Sources       []*ResizeSource `protobuf:"bytes,4,rep,name=Sources" json:"Sources,omitempty"`
-	NodeStatus    *NodeStatus     `protobuf:"bytes,7,opt,name=NodeStatus" json:"NodeStatus,omitempty"`
-	ClusterStatus *ClusterStatus  `protobuf:"bytes,6,opt,name=ClusterStatus" json:"ClusterStatus,omitempty"`
+	JobID                int64           `protobuf:"varint,1,opt,name=JobID,proto3" json:"JobID,omitempty"`
+	Node                 *Node           `protobuf:"bytes,2,opt,name=Node" json:"Node,omitempty"`
+	Coordinator          *Node           `protobuf:"bytes,3,opt,name=Coordinator" json:"Coordinator,omitempty"`
+	Sources              []*ResizeSource `protobuf:"bytes,4,rep,name=Sources" json:"Sources,omitempty"`
+	NodeStatus           *NodeStatus     `protobuf:"bytes,7,opt,name=NodeStatus" json:"NodeStatus,omitempty"`
+	ClusterStatus        *ClusterStatus  `protobuf:"bytes,6,opt,name=ClusterStatus" json:"ClusterStatus,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+	XXX_unrecognized     []byte          `json:"-"`
+	XXX_sizecache        int32           `json:"-"`
 }
 
-func (m *ResizeInstruction) Reset()                    { *m = ResizeInstruction{} }
-func (m *ResizeInstruction) String() string            { return proto.CompactTextString(m) }
-func (*ResizeInstruction) ProtoMessage()               {}
-func (*ResizeInstruction) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{27} }
+func (m *ResizeInstruction) Reset()         { *m = ResizeInstruction{} }
+func (m *ResizeInstruction) String() string { return proto.CompactTextString(m) }
+func (*ResizeInstruction) ProtoMessage()    {}
+func (*ResizeInstruction) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{27}
+}
+func (m *ResizeInstruction) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ResizeInstruction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ResizeInstruction.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *ResizeInstruction) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ResizeInstruction.Merge(dst, src)
+}
+func (m *ResizeInstruction) XXX_Size() int {
+	return m.Size()
+}
+func (m *ResizeInstruction) XXX_DiscardUnknown() {
+	xxx_messageInfo_ResizeInstruction.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ResizeInstruction proto.InternalMessageInfo
 
 func (m *ResizeInstruction) GetJobID() int64 {
 	if m != nil {
@@ -921,17 +1753,48 @@ func (m *ResizeInstruction) GetClusterStatus() *ClusterStatus {
 }
 
 type ResizeSource struct {
-	Node  *Node  `protobuf:"bytes,1,opt,name=Node" json:"Node,omitempty"`
-	Index string `protobuf:"bytes,2,opt,name=Index,proto3" json:"Index,omitempty"`
-	Field string `protobuf:"bytes,3,opt,name=Field,proto3" json:"Field,omitempty"`
-	View  string `protobuf:"bytes,4,opt,name=View,proto3" json:"View,omitempty"`
-	Shard uint64 `protobuf:"varint,5,opt,name=Shard,proto3" json:"Shard,omitempty"`
+	Node                 *Node    `protobuf:"bytes,1,opt,name=Node" json:"Node,omitempty"`
+	Index                string   `protobuf:"bytes,2,opt,name=Index,proto3" json:"Index,omitempty"`
+	Field                string   `protobuf:"bytes,3,opt,name=Field,proto3" json:"Field,omitempty"`
+	View                 string   `protobuf:"bytes,4,opt,name=View,proto3" json:"View,omitempty"`
+	Shard                uint64   `protobuf:"varint,5,opt,name=Shard,proto3" json:"Shard,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *ResizeSource) Reset()                    { *m = ResizeSource{} }
-func (m *ResizeSource) String() string            { return proto.CompactTextString(m) }
-func (*ResizeSource) ProtoMessage()               {}
-func (*ResizeSource) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{28} }
+func (m *ResizeSource) Reset()         { *m = ResizeSource{} }
+func (m *ResizeSource) String() string { return proto.CompactTextString(m) }
+func (*ResizeSource) ProtoMessage()    {}
+func (*ResizeSource) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{28}
+}
+func (m *ResizeSource) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ResizeSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ResizeSource.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *ResizeSource) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ResizeSource.Merge(dst, src)
+}
+func (m *ResizeSource) XXX_Size() int {
+	return m.Size()
+}
+func (m *ResizeSource) XXX_DiscardUnknown() {
+	xxx_messageInfo_ResizeSource.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ResizeSource proto.InternalMessageInfo
 
 func (m *ResizeSource) GetNode() *Node {
 	if m != nil {
@@ -969,17 +1832,46 @@ func (m *ResizeSource) GetShard() uint64 {
 }
 
 type ResizeInstructionComplete struct {
-	JobID int64  `protobuf:"varint,1,opt,name=JobID,proto3" json:"JobID,omitempty"`
-	Node  *Node  `protobuf:"bytes,2,opt,name=Node" json:"Node,omitempty"`
-	Error string `protobuf:"bytes,3,opt,name=Error,proto3" json:"Error,omitempty"`
+	JobID                int64    `protobuf:"varint,1,opt,name=JobID,proto3" json:"JobID,omitempty"`
+	Node                 *Node    `protobuf:"bytes,2,opt,name=Node" json:"Node,omitempty"`
+	Error                string   `protobuf:"bytes,3,opt,name=Error,proto3" json:"Error,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *ResizeInstructionComplete) Reset()         { *m = ResizeInstructionComplete{} }
 func (m *ResizeInstructionComplete) String() string { return proto.CompactTextString(m) }
 func (*ResizeInstructionComplete) ProtoMessage()    {}
 func (*ResizeInstructionComplete) Descriptor() ([]byte, []int) {
-	return fileDescriptorPrivate, []int{29}
+	return fileDescriptor_private_b229d027a4642df7, []int{29}
 }
+func (m *ResizeInstructionComplete) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ResizeInstructionComplete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ResizeInstructionComplete.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *ResizeInstructionComplete) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ResizeInstructionComplete.Merge(dst, src)
+}
+func (m *ResizeInstructionComplete) XXX_Size() int {
+	return m.Size()
+}
+func (m *ResizeInstructionComplete) XXX_DiscardUnknown() {
+	xxx_messageInfo_ResizeInstructionComplete.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ResizeInstructionComplete proto.InternalMessageInfo
 
 func (m *ResizeInstructionComplete) GetJobID() int64 {
 	if m != nil {
@@ -1003,13 +1895,44 @@ func (m *ResizeInstructionComplete) GetError() string {
 }
 
 type SetCoordinatorMessage struct {
-	New *Node `protobuf:"bytes,1,opt,name=New" json:"New,omitempty"`
+	New                  *Node    `protobuf:"bytes,1,opt,name=New" json:"New,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *SetCoordinatorMessage) Reset()                    { *m = SetCoordinatorMessage{} }
-func (m *SetCoordinatorMessage) String() string            { return proto.CompactTextString(m) }
-func (*SetCoordinatorMessage) ProtoMessage()               {}
-func (*SetCoordinatorMessage) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{30} }
+func (m *SetCoordinatorMessage) Reset()         { *m = SetCoordinatorMessage{} }
+func (m *SetCoordinatorMessage) String() string { return proto.CompactTextString(m) }
+func (*SetCoordinatorMessage) ProtoMessage()    {}
+func (*SetCoordinatorMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{30}
+}
+func (m *SetCoordinatorMessage) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *SetCoordinatorMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_SetCoordinatorMessage.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *SetCoordinatorMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SetCoordinatorMessage.Merge(dst, src)
+}
+func (m *SetCoordinatorMessage) XXX_Size() int {
+	return m.Size()
+}
+func (m *SetCoordinatorMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_SetCoordinatorMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SetCoordinatorMessage proto.InternalMessageInfo
 
 func (m *SetCoordinatorMessage) GetNew() *Node {
 	if m != nil {
@@ -1019,13 +1942,44 @@ func (m *SetCoordinatorMessage) GetNew() *Node {
 }
 
 type UpdateCoordinatorMessage struct {
-	New *Node `protobuf:"bytes,1,opt,name=New" json:"New,omitempty"`
+	New                  *Node    `protobuf:"bytes,1,opt,name=New" json:"New,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *UpdateCoordinatorMessage) Reset()                    { *m = UpdateCoordinatorMessage{} }
-func (m *UpdateCoordinatorMessage) String() string            { return proto.CompactTextString(m) }
-func (*UpdateCoordinatorMessage) ProtoMessage()               {}
-func (*UpdateCoordinatorMessage) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{31} }
+func (m *UpdateCoordinatorMessage) Reset()         { *m = UpdateCoordinatorMessage{} }
+func (m *UpdateCoordinatorMessage) String() string { return proto.CompactTextString(m) }
+func (*UpdateCoordinatorMessage) ProtoMessage()    {}
+func (*UpdateCoordinatorMessage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{31}
+}
+func (m *UpdateCoordinatorMessage) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *UpdateCoordinatorMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_UpdateCoordinatorMessage.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *UpdateCoordinatorMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UpdateCoordinatorMessage.Merge(dst, src)
+}
+func (m *UpdateCoordinatorMessage) XXX_Size() int {
+	return m.Size()
+}
+func (m *UpdateCoordinatorMessage) XXX_DiscardUnknown() {
+	xxx_messageInfo_UpdateCoordinatorMessage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UpdateCoordinatorMessage proto.InternalMessageInfo
 
 func (m *UpdateCoordinatorMessage) GetNew() *Node {
 	if m != nil {
@@ -1035,14 +1989,45 @@ func (m *UpdateCoordinatorMessage) GetNew() *Node {
 }
 
 type Topology struct {
-	ClusterID string   `protobuf:"bytes,1,opt,name=ClusterID,proto3" json:"ClusterID,omitempty"`
-	NodeIDs   []string `protobuf:"bytes,2,rep,name=NodeIDs" json:"NodeIDs,omitempty"`
+	ClusterID            string   `protobuf:"bytes,1,opt,name=ClusterID,proto3" json:"ClusterID,omitempty"`
+	NodeIDs              []string `protobuf:"bytes,2,rep,name=NodeIDs" json:"NodeIDs,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *Topology) Reset()                    { *m = Topology{} }
-func (m *Topology) String() string            { return proto.CompactTextString(m) }
-func (*Topology) ProtoMessage()               {}
-func (*Topology) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{32} }
+func (m *Topology) Reset()         { *m = Topology{} }
+func (m *Topology) String() string { return proto.CompactTextString(m) }
+func (*Topology) ProtoMessage()    {}
+func (*Topology) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{32}
+}
+func (m *Topology) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Topology) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Topology.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *Topology) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Topology.Merge(dst, src)
+}
+func (m *Topology) XXX_Size() int {
+	return m.Size()
+}
+func (m *Topology) XXX_DiscardUnknown() {
+	xxx_messageInfo_Topology.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Topology proto.InternalMessageInfo
 
 func (m *Topology) GetClusterID() string {
 	if m != nil {
@@ -1059,12 +2044,43 @@ func (m *Topology) GetNodeIDs() []string {
 }
 
 type RecalculateCaches struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *RecalculateCaches) Reset()                    { *m = RecalculateCaches{} }
-func (m *RecalculateCaches) String() string            { return proto.CompactTextString(m) }
-func (*RecalculateCaches) ProtoMessage()               {}
-func (*RecalculateCaches) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{33} }
+func (m *RecalculateCaches) Reset()         { *m = RecalculateCaches{} }
+func (m *RecalculateCaches) String() string { return proto.CompactTextString(m) }
+func (*RecalculateCaches) ProtoMessage()    {}
+func (*RecalculateCaches) Descriptor() ([]byte, []int) {
+	return fileDescriptor_private_b229d027a4642df7, []int{33}
+}
+func (m *RecalculateCaches) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *RecalculateCaches) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_RecalculateCaches.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *RecalculateCaches) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RecalculateCaches.Merge(dst, src)
+}
+func (m *RecalculateCaches) XXX_Size() int {
+	return m.Size()
+}
+func (m *RecalculateCaches) XXX_DiscardUnknown() {
+	xxx_messageInfo_RecalculateCaches.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RecalculateCaches proto.InternalMessageInfo
 
 func init() {
 	proto.RegisterType((*IndexMeta)(nil), "internal.IndexMeta")
@@ -1074,6 +2090,7 @@ func init() {
 	proto.RegisterType((*BlockDataResponse)(nil), "internal.BlockDataResponse")
 	proto.RegisterType((*Cache)(nil), "internal.Cache")
 	proto.RegisterType((*MaxShards)(nil), "internal.MaxShards")
+	proto.RegisterMapType((map[string]uint64)(nil), "internal.MaxShards.StandardEntry")
 	proto.RegisterType((*CreateShardMessage)(nil), "internal.CreateShardMessage")
 	proto.RegisterType((*DeleteIndexMessage)(nil), "internal.DeleteIndexMessage")
 	proto.RegisterType((*CreateIndexMessage)(nil), "internal.CreateIndexMessage")
@@ -1137,6 +2154,9 @@ func (m *IndexMeta) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i++
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1218,6 +2238,14 @@ func (m *FieldOptions) MarshalTo(dAtA []byte) (int, error) {
 		i++
 		i = encodeVarintPrivate(dAtA, i, uint64(m.BitDepth))
 	}
+	if m.Scale != 0 {
+		dAtA[i] = 0x78
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Scale))
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1242,6 +2270,9 @@ func (m *ImportResponse) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Err)))
 		i += copy(dAtA[i:], m.Err)
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1288,6 +2319,9 @@ func (m *BlockDataRequest) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.View)))
 		i += copy(dAtA[i:], m.View)
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1340,6 +2374,9 @@ func (m *BlockDataResponse) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPrivate(dAtA, i, uint64(j3))
 		i += copy(dAtA[i:], dAtA4[:j3])
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1375,6 +2412,9 @@ func (m *Cache) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPrivate(dAtA, i, uint64(j5))
 		i += copy(dAtA[i:], dAtA6[:j5])
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1409,6 +2449,9 @@ func (m *MaxShards) MarshalTo(dAtA []byte) (int, error) {
 			i = encodeVarintPrivate(dAtA, i, uint64(v))
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1444,6 +2487,9 @@ func (m *CreateShardMessage) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
 		i += copy(dAtA[i:], m.Field)
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1468,6 +2514,9 @@ func (m *DeleteIndexMessage) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
 		i += copy(dAtA[i:], m.Index)
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1502,6 +2551,9 @@ func (m *CreateIndexMessage) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i += n7
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1542,6 +2594,9 @@ func (m *CreateFieldMessage) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i += n8
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1572,6 +2627,9 @@ func (m *DeleteFieldMessage) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
 		i += copy(dAtA[i:], m.Field)
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1607,6 +2665,9 @@ func (m *DeleteAvailableShardMessage) MarshalTo(dAtA []byte) (int, error) {
 		i++
 		i = encodeVarintPrivate(dAtA, i, uint64(m.ShardID))
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1656,6 +2717,9 @@ func (m *Field) MarshalTo(dAtA []byte) (int, error) {
 			i += copy(dAtA[i:], s)
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1686,6 +2750,9 @@ func (m *Schema) MarshalTo(dAtA []byte) (int, error) {
 			i += n
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1722,6 +2789,9 @@ func (m *Index) MarshalTo(dAtA []byte) (int, error) {
 			i += n
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1757,6 +2827,9 @@ func (m *URI) MarshalTo(dAtA []byte) (int, error) {
 		i++
 		i = encodeVarintPrivate(dAtA, i, uint64(m.Port))
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1807,6 +2880,9 @@ func (m *Node) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.State)))
 		i += copy(dAtA[i:], m.State)
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1837,6 +2913,9 @@ func (m *NodeStateMessage) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.State)))
 		i += copy(dAtA[i:], m.State)
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1870,6 +2949,9 @@ func (m *NodeEventMessage) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i += n11
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1920,6 +3002,9 @@ func (m *NodeStatus) MarshalTo(dAtA []byte) (int, error) {
 			i += n
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1956,6 +3041,9 @@ func (m *IndexStatus) MarshalTo(dAtA []byte) (int, error) {
 			i += n
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1997,6 +3085,9 @@ func (m *FieldStatus) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPrivate(dAtA, i, uint64(j14))
 		i += copy(dAtA[i:], dAtA15[:j14])
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -2039,6 +3130,9 @@ func (m *ClusterStatus) MarshalTo(dAtA []byte) (int, error) {
 			i += n
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -2079,6 +3173,9 @@ func (m *BSIGroup) MarshalTo(dAtA []byte) (int, error) {
 		i++
 		i = encodeVarintPrivate(dAtA, i, uint64(m.Max))
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -2115,6 +3212,9 @@ func (m *CreateViewMessage) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.View)))
 		i += copy(dAtA[i:], m.View)
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -2151,6 +3251,9 @@ func (m *DeleteViewMessage) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.View)))
 		i += copy(dAtA[i:], m.View)
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -2226,6 +3329,9 @@ func (m *ResizeInstruction) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i += n19
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -2277,6 +3383,9 @@ func (m *ResizeSource) MarshalTo(dAtA []byte) (int, error) {
 		i++
 		i = encodeVarintPrivate(dAtA, i, uint64(m.Shard))
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -2316,6 +3425,9 @@ func (m *ResizeInstructionComplete) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Error)))
 		i += copy(dAtA[i:], m.Error)
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -2344,6 +3456,9 @@ func (m *SetCoordinatorMessage) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i += n22
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -2372,6 +3487,9 @@ func (m *UpdateCoordinatorMessage) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i += n23
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -2411,6 +3529,9 @@ func (m *Topology) MarshalTo(dAtA []byte) (int, error) {
 			i += copy(dAtA[i:], s)
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -2429,6 +3550,9 @@ func (m *RecalculateCaches) MarshalTo(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -2442,6 +3566,9 @@ func encodeVarintPrivate(dAtA []byte, offset int, v uint64) int {
 	return offset + 1
 }
 func (m *IndexMeta) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	if m.Keys {
@@ -2450,10 +3577,16 @@ func (m *IndexMeta) Size() (n int) {
 	if m.TrackExistence {
 		n += 2
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *FieldOptions) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.CacheType)
@@ -2489,20 +3622,35 @@ func (m *FieldOptions) Size() (n int) {
 	if m.BitDepth != 0 {
 		n += 1 + sovPrivate(uint64(m.BitDepth))
 	}
+	if m.Scale != 0 {
+		n += 1 + sovPrivate(uint64(m.Scale))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *ImportResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Err)
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *BlockDataRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Index)
@@ -2523,10 +3671,16 @@ func (m *BlockDataRequest) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *BlockDataResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	if len(m.RowIDs) > 0 {
@@ -2543,10 +3697,16 @@ func (m *BlockDataResponse) Size() (n int) {
 		}
 		n += 1 + sovPrivate(uint64(l)) + l
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *Cache) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	if len(m.IDs) > 0 {
@@ -2556,10 +3716,16 @@ func (m *Cache) Size() (n int) {
 		}
 		n += 1 + sovPrivate(uint64(l)) + l
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *MaxShards) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	if len(m.Standard) > 0 {
@@ -2570,10 +3736,16 @@ func (m *MaxShards) Size() (n int) {
 			n += mapEntrySize + 1 + sovPrivate(uint64(mapEntrySize))
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *CreateShardMessage) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Index)
@@ -2587,20 +3759,32 @@ func (m *CreateShardMessage) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *DeleteIndexMessage) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Index)
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *CreateIndexMessage) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Index)
@@ -2611,10 +3795,16 @@ func (m *CreateIndexMessage) Size() (n int) {
 		l = m.Meta.Size()
 		n += 1 + l + sovPrivate(uint64(l))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *CreateFieldMessage) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Index)
@@ -2629,10 +3819,16 @@ func (m *CreateFieldMessage) Size() (n int) {
 		l = m.Meta.Size()
 		n += 1 + l + sovPrivate(uint64(l))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *DeleteFieldMessage) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Index)
@@ -2643,10 +3839,16 @@ func (m *DeleteFieldMessage) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *DeleteAvailableShardMessage) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Index)
@@ -2660,10 +3862,16 @@ func (m *DeleteAvailableShardMessage) Size() (n int) {
 	if m.ShardID != 0 {
 		n += 1 + sovPrivate(uint64(m.ShardID))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *Field) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Name)
@@ -2680,10 +3888,16 @@ func (m *Field) Size() (n int) {
 			n += 1 + l + sovPrivate(uint64(l))
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *Schema) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	if len(m.Indexes) > 0 {
@@ -2692,10 +3906,16 @@ func (m *Schema) Size() (n int) {
 			n += 1 + l + sovPrivate(uint64(l))
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *Index) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Name)
@@ -2708,10 +3928,16 @@ func (m *Index) Size() (n int) {
 			n += 1 + l + sovPrivate(uint64(l))
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *URI) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Scheme)
@@ -2725,10 +3951,16 @@ func (m *URI) Size() (n int) {
 	if m.Port != 0 {
 		n += 1 + sovPrivate(uint64(m.Port))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *Node) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.ID)
@@ -2746,10 +3978,16 @@ func (m *Node) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *NodeStateMessage) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.NodeID)
@@ -2760,10 +3998,16 @@ func (m *NodeStateMessage) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *NodeEventMessage) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	if m.Event != 0 {
@@ -2773,10 +4017,16 @@ func (m *NodeEventMessage) Size() (n int) {
 		l = m.Node.Size()
 		n += 1 + l + sovPrivate(uint64(l))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *NodeStatus) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	if m.Node != nil {
@@ -2793,10 +4043,16 @@ func (m *NodeStatus) Size() (n int) {
 			n += 1 + l + sovPrivate(uint64(l))
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *IndexStatus) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Name)
@@ -2809,10 +4065,16 @@ func (m *IndexStatus) Size() (n int) {
 			n += 1 + l + sovPrivate(uint64(l))
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *FieldStatus) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Name)
@@ -2826,10 +4088,16 @@ func (m *FieldStatus) Size() (n int) {
 		}
 		n += 1 + sovPrivate(uint64(l)) + l
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *ClusterStatus) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.ClusterID)
@@ -2846,10 +4114,16 @@ func (m *ClusterStatus) Size() (n int) {
 			n += 1 + l + sovPrivate(uint64(l))
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *BSIGroup) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Name)
@@ -2866,10 +4140,16 @@ func (m *BSIGroup) Size() (n int) {
 	if m.Max != 0 {
 		n += 1 + sovPrivate(uint64(m.Max))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *CreateViewMessage) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Index)
@@ -2884,10 +4164,16 @@ func (m *CreateViewMessage) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *DeleteViewMessage) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Index)
@@ -2902,10 +4188,16 @@ func (m *DeleteViewMessage) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *ResizeInstruction) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	if m.JobID != 0 {
@@ -2933,10 +4225,16 @@ func (m *ResizeInstruction) Size() (n int) {
 		l = m.NodeStatus.Size()
 		n += 1 + l + sovPrivate(uint64(l))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *ResizeSource) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	if m.Node != nil {
@@ -2958,10 +4256,16 @@ func (m *ResizeSource) Size() (n int) {
 	if m.Shard != 0 {
 		n += 1 + sovPrivate(uint64(m.Shard))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *ResizeInstructionComplete) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	if m.JobID != 0 {
@@ -2975,30 +4279,48 @@ func (m *ResizeInstructionComplete) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPrivate(uint64(l))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *SetCoordinatorMessage) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	if m.New != nil {
 		l = m.New.Size()
 		n += 1 + l + sovPrivate(uint64(l))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *UpdateCoordinatorMessage) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	if m.New != nil {
 		l = m.New.Size()
 		n += 1 + l + sovPrivate(uint64(l))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *Topology) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.ClusterID)
@@ -3011,12 +4333,21 @@ func (m *Topology) Size() (n int) {
 			n += 1 + l + sovPrivate(uint64(l))
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *RecalculateCaches) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
@@ -3114,6 +4445,7 @@ func (m *IndexMeta) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -3374,6 +4706,25 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 					break
 				}
 			}
+		case 15:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Scale", wireType)
+			}
+			m.Scale = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPrivate
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Scale |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipPrivate(dAtA[iNdEx:])
@@ -3386,6 +4737,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -3465,6 +4817,7 @@ func (m *ImportResponse) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -3640,6 +4993,7 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -3719,6 +5073,17 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
+				var elementCount int
+				var count int
+				for _, integer := range dAtA {
+					if integer < 128 {
+						count++
+					}
+				}
+				elementCount = count
+				if elementCount != 0 && len(m.RowIDs) == 0 {
+					m.RowIDs = make([]uint64, 0, elementCount)
+				}
 				for iNdEx < postIndex {
 					var v uint64
 					for shift := uint(0); ; shift += 7 {
@@ -3781,6 +5146,17 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
+				var elementCount int
+				var count int
+				for _, integer := range dAtA {
+					if integer < 128 {
+						count++
+					}
+				}
+				elementCount = count
+				if elementCount != 0 && len(m.ColumnIDs) == 0 {
+					m.ColumnIDs = make([]uint64, 0, elementCount)
+				}
 				for iNdEx < postIndex {
 					var v uint64
 					for shift := uint(0); ; shift += 7 {
@@ -3814,6 +5190,7 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -3893,6 +5270,17 @@ func (m *Cache) Unmarshal(dAtA []byte) error {
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
+				var elementCount int
+				var count int
+				for _, integer := range dAtA {
+					if integer < 128 {
+						count++
+					}
+				}
+				elementCount = count
+				if elementCount != 0 && len(m.IDs) == 0 {
+					m.IDs = make([]uint64, 0, elementCount)
+				}
 				for iNdEx < postIndex {
 					var v uint64
 					for shift := uint(0); ; shift += 7 {
@@ -3926,6 +5314,7 @@ func (m *Cache) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -4083,6 +5472,7 @@ func (m *MaxShards) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -4210,6 +5600,7 @@ func (m *CreateShardMessage) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -4289,6 +5680,7 @@ func (m *DeleteIndexMessage) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -4401,6 +5793,7 @@ func (m *CreateIndexMessage) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -4542,6 +5935,7 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -4650,6 +6044,7 @@ func (m *DeleteFieldMessage) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -4777,6 +6172,7 @@ func (m *DeleteAvailableShardMessage) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -4918,6 +6314,7 @@ func (m *Field) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -4999,6 +6396,7 @@ func (m *Schema) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -5109,6 +6507,7 @@ func (m *Index) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -5236,6 +6635,7 @@ func (m *URI) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -5397,6 +6797,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -5505,6 +6906,7 @@ func (m *NodeStateMessage) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -5607,6 +7009,7 @@ func (m *NodeEventMessage) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -5754,6 +7157,7 @@ func (m *NodeStatus) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -5864,6 +7268,7 @@ func (m *IndexStatus) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -5972,6 +7377,17 @@ func (m *FieldStatus) Unmarshal(dAtA []byte) error {
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
+				var elementCount int
+				var count int
+				for _, integer := range dAtA {
+					if integer < 128 {
+						count++
+					}
+				}
+				elementCount = count
+				if elementCount != 0 && len(m.AvailableShards) == 0 {
+					m.AvailableShards = make([]uint64, 0, elementCount)
+				}
 				for iNdEx < postIndex {
 					var v uint64
 					for shift := uint(0); ; shift += 7 {
@@ -6005,6 +7421,7 @@ func (m *FieldStatus) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -6144,6 +7561,7 @@ func (m *ClusterStatus) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -6290,6 +7708,7 @@ func (m *BSIGroup) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -6427,6 +7846,7 @@ func (m *CreateViewMessage) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -6564,6 +7984,7 @@ func (m *DeleteViewMessage) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -6796,6 +8217,7 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -6985,6 +8407,7 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -7116,6 +8539,7 @@ func (m *ResizeInstructionComplete) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -7199,6 +8623,7 @@ func (m *SetCoordinatorMessage) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -7282,6 +8707,7 @@ func (m *UpdateCoordinatorMessage) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -7390,6 +8816,7 @@ func (m *Topology) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -7440,6 +8867,7 @@ func (m *RecalculateCaches) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -7554,82 +8982,82 @@ var (
 	ErrIntOverflowPrivate   = fmt.Errorf("proto: integer overflow")
 )
 
-func init() { proto.RegisterFile("private.proto", fileDescriptorPrivate) }
+func init() { proto.RegisterFile("private.proto", fileDescriptor_private_b229d027a4642df7) }
 
-var fileDescriptorPrivate = []byte{
-	// 1180 bytes of a gzipped FileDescriptorProto
+var fileDescriptor_private_b229d027a4642df7 = []byte{
+	// 1174 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xdb, 0x6e, 0x1b, 0x45,
-	0x18, 0x66, 0x0f, 0x71, 0xec, 0xdf, 0x75, 0xea, 0x4c, 0xdb, 0xb0, 0x2d, 0x28, 0x98, 0x51, 0x45,
-	0x4d, 0x25, 0x42, 0xd5, 0x72, 0xc1, 0xa9, 0x52, 0x71, 0x1c, 0xca, 0x52, 0x12, 0xca, 0x38, 0xc9,
-	0x1d, 0x17, 0x13, 0x7b, 0xd4, 0xac, 0xb2, 0xde, 0x35, 0xbb, 0xb3, 0x49, 0xdc, 0x0b, 0x6e, 0x41,
-	0xe2, 0x05, 0xfa, 0x04, 0x3c, 0x0b, 0x97, 0x3c, 0x02, 0x0a, 0x2f, 0x82, 0xe6, 0x9f, 0xd9, 0x83,
-	0x1d, 0x87, 0x44, 0x81, 0xbb, 0xf9, 0xbf, 0x7f, 0xfe, 0xf3, 0x61, 0x67, 0xa1, 0x35, 0x49, 0x82,
-	0x63, 0x2e, 0xc5, 0xc6, 0x24, 0x89, 0x65, 0x4c, 0xea, 0x41, 0x24, 0x45, 0x12, 0xf1, 0x90, 0x3e,
-	0x87, 0x86, 0x1f, 0x8d, 0xc4, 0xe9, 0xb6, 0x90, 0x9c, 0x10, 0x70, 0x5f, 0x88, 0x69, 0xea, 0x39,
-	0x1d, 0xab, 0x5b, 0x67, 0x78, 0x26, 0x1f, 0xc0, 0xca, 0x6e, 0xc2, 0x87, 0x47, 0x5b, 0xa7, 0x41,
-	0x2a, 0x45, 0x34, 0x14, 0x9e, 0x8b, 0xdc, 0x39, 0x94, 0xbe, 0xb1, 0xe1, 0xc6, 0xd7, 0x81, 0x08,
-	0x47, 0xdf, 0x4f, 0x64, 0x10, 0x47, 0x29, 0x79, 0x17, 0x1a, 0x9b, 0x7c, 0x78, 0x28, 0x76, 0xa7,
-	0x13, 0x81, 0x1a, 0x1b, 0xac, 0x04, 0x0a, 0xee, 0x20, 0x78, 0xad, 0x35, 0xb6, 0x58, 0x09, 0x90,
-	0x0e, 0x34, 0x77, 0x83, 0xb1, 0xf8, 0x21, 0xe3, 0x91, 0xcc, 0xc6, 0xde, 0x12, 0x4a, 0x57, 0x21,
-	0xe5, 0x2a, 0x2a, 0xae, 0x23, 0x0b, 0xcf, 0xe4, 0x36, 0x38, 0xdb, 0x41, 0xe4, 0x35, 0x3a, 0x56,
-	0xd7, 0xe9, 0xd9, 0x9e, 0xc5, 0x14, 0x89, 0x28, 0x3f, 0xf5, 0xa0, 0x82, 0xf2, 0xd3, 0x22, 0xd4,
-	0xe6, 0x6c, 0xa8, 0x3b, 0xf1, 0x40, 0xf2, 0x68, 0xc4, 0x93, 0xd1, 0x7e, 0x20, 0x4e, 0xbc, 0x1b,
-	0x3a, 0xd4, 0x59, 0x54, 0xc9, 0xf6, 0x78, 0x2a, 0xbc, 0x96, 0x52, 0xc9, 0xf0, 0x4c, 0xee, 0x41,
-	0xbd, 0x17, 0xc8, 0xbe, 0x98, 0xc8, 0x43, 0x6f, 0xa5, 0x63, 0x75, 0x5d, 0x56, 0xd0, 0x94, 0xc2,
-	0x8a, 0x3f, 0x9e, 0xc4, 0x89, 0x64, 0x22, 0x9d, 0xc4, 0x51, 0x2a, 0x48, 0x1b, 0x9c, 0xad, 0x24,
-	0xf1, 0x2c, 0x74, 0x5e, 0x1d, 0xe9, 0xcf, 0xd0, 0xee, 0x85, 0xf1, 0xf0, 0xa8, 0xcf, 0x25, 0x67,
-	0xe2, 0xa7, 0x4c, 0xa4, 0x92, 0xdc, 0x86, 0x25, 0xac, 0x8d, 0xb9, 0xa7, 0x09, 0x85, 0x62, 0x9e,
-	0x3d, 0x5b, 0xa3, 0x48, 0x28, 0x14, 0xe5, 0x31, 0xd3, 0x2e, 0xd3, 0x84, 0x42, 0x07, 0x87, 0x3c,
-	0x19, 0x61, 0x86, 0x5d, 0xa6, 0x09, 0xe5, 0x3f, 0x46, 0xa7, 0xd3, 0x8a, 0x67, 0xea, 0xc3, 0x6a,
-	0xc5, 0xbe, 0x71, 0x73, 0x0d, 0x6a, 0x2c, 0x3e, 0xf1, 0xfb, 0xa9, 0x67, 0x75, 0x9c, 0xae, 0xcb,
-	0x0c, 0x85, 0xc5, 0x8b, 0xc3, 0x6c, 0x1c, 0x29, 0x96, 0x8d, 0xac, 0x12, 0xa0, 0x77, 0x61, 0x09,
-	0x2b, 0xa9, 0xa2, 0x2c, 0x65, 0xd5, 0x91, 0xfe, 0x62, 0x41, 0x63, 0x9b, 0x9f, 0xa2, 0x1b, 0x29,
-	0x79, 0x0a, 0xf5, 0x3c, 0xaf, 0x78, 0xa9, 0xf9, 0xf8, 0xfd, 0x8d, 0xbc, 0x31, 0x37, 0x8a, 0x6b,
-	0x1b, 0xf9, 0x9d, 0xad, 0x48, 0x26, 0x53, 0x56, 0x88, 0xdc, 0xfb, 0x02, 0x5a, 0x33, 0x2c, 0x65,
-	0xef, 0x48, 0x4c, 0xf3, 0xac, 0x1e, 0x89, 0xa9, 0x8a, 0xff, 0x98, 0x87, 0x99, 0xc0, 0x5c, 0xb9,
-	0x4c, 0x13, 0x9f, 0xdb, 0x9f, 0x5a, 0x74, 0x1f, 0xc8, 0x66, 0x22, 0xb8, 0x14, 0x68, 0x64, 0x5b,
-	0xa4, 0x29, 0x7f, 0x25, 0x2e, 0xce, 0xb8, 0xce, 0xa2, 0x5d, 0xcd, 0x62, 0x51, 0x07, 0xa7, 0x52,
-	0x07, 0xfa, 0x10, 0x48, 0x5f, 0x84, 0x42, 0x0a, 0x33, 0x55, 0xff, 0xa2, 0x97, 0x0e, 0x72, 0x1f,
-	0x2e, 0xbf, 0x4b, 0x1e, 0x80, 0xab, 0x46, 0x14, 0x5d, 0x68, 0x3e, 0xbe, 0x55, 0xe6, 0xa9, 0x98,
-	0x5e, 0x86, 0x17, 0x68, 0x98, 0x2b, 0x45, 0x7f, 0x2e, 0x0d, 0x6c, 0x41, 0x2b, 0x3d, 0x34, 0xa6,
-	0x1c, 0x34, 0xb5, 0x56, 0x9a, 0xaa, 0x8e, 0xb7, 0xb1, 0xf6, 0x2c, 0x0f, 0xf7, 0xba, 0xd6, 0xe8,
-	0x10, 0xde, 0xd1, 0x1a, 0xbe, 0x3a, 0xe6, 0x41, 0xc8, 0x0f, 0xc2, 0x2b, 0x56, 0x64, 0x81, 0xe3,
-	0x1e, 0x2c, 0xa3, 0xac, 0xdf, 0x37, 0x53, 0x90, 0x93, 0xf4, 0x47, 0x73, 0x5f, 0xb5, 0xfe, 0x0e,
-	0x1f, 0x0b, 0xa3, 0x0d, 0xcf, 0x45, 0xbc, 0xf6, 0xe5, 0xf1, 0x2a, 0xc3, 0x6a, 0x5c, 0xd4, 0x8a,
-	0x74, 0x94, 0x61, 0x24, 0xe8, 0x13, 0xa8, 0x0d, 0x86, 0x87, 0x62, 0xcc, 0xc9, 0x87, 0xb0, 0x8c,
-	0x1e, 0x8a, 0xd4, 0x74, 0xf4, 0xcd, 0xb9, 0x4a, 0xb1, 0x9c, 0x4f, 0xfb, 0x26, 0xb2, 0x85, 0x3e,
-	0x3d, 0x80, 0x1a, 0x5a, 0x4f, 0x3d, 0x77, 0x5e, 0x0d, 0xe2, 0xcc, 0xb0, 0xe9, 0x16, 0x38, 0x7b,
-	0xcc, 0x57, 0x93, 0x8a, 0x1e, 0xe4, 0x5a, 0x0c, 0xa5, 0x74, 0x7f, 0x13, 0xa7, 0xd2, 0xe4, 0x09,
-	0xcf, 0x0a, 0x7b, 0x19, 0x27, 0x12, 0x73, 0xd4, 0x62, 0x78, 0xa6, 0x29, 0xb8, 0x3b, 0xf1, 0x48,
-	0x90, 0x15, 0xb0, 0xfd, 0xbe, 0xd1, 0x61, 0xfb, 0x7d, 0xf2, 0x1e, 0xaa, 0x37, 0xa9, 0x69, 0x95,
-	0x4e, 0xec, 0x31, 0x9f, 0xa1, 0xe1, 0xfb, 0xd0, 0xf2, 0xd3, 0xcd, 0x38, 0x4e, 0x46, 0x41, 0xc4,
-	0x65, 0x9c, 0x98, 0x6f, 0xc7, 0x2c, 0x88, 0x13, 0x24, 0xb9, 0xd4, 0x9b, 0xbe, 0xc1, 0x34, 0x41,
-	0x9f, 0x41, 0x5b, 0x19, 0x45, 0x22, 0xaf, 0xf7, 0x1a, 0xd4, 0x14, 0x56, 0x38, 0x61, 0xa8, 0x52,
-	0x83, 0x5d, 0xd5, 0xf0, 0x9d, 0xd6, 0xb0, 0x75, 0x2c, 0x22, 0x59, 0xe9, 0x18, 0xa4, 0x51, 0x41,
-	0x8b, 0x69, 0x82, 0x50, 0x1d, 0xa0, 0x89, 0x64, 0xa5, 0x8c, 0x44, 0xa1, 0x0c, 0x79, 0xf4, 0x37,
-	0x0b, 0x20, 0x77, 0x28, 0x4b, 0x0b, 0x11, 0xeb, 0x62, 0x11, 0xd2, 0xcd, 0x2b, 0x6f, 0xa6, 0xa5,
-	0x5d, 0xde, 0xd2, 0x38, 0xcb, 0x3b, 0xe3, 0xe3, 0xb2, 0x33, 0x74, 0x49, 0xef, 0xcc, 0x75, 0x86,
-	0xb6, 0x5a, 0xf6, 0xc7, 0x4b, 0x68, 0x56, 0xf0, 0x85, 0x5d, 0xf2, 0x51, 0xd1, 0x25, 0xf6, 0xbc,
-	0x4a, 0xc4, 0x8d, 0xca, 0xbc, 0x57, 0x5e, 0x40, 0xb3, 0x02, 0x2f, 0xd4, 0xd8, 0x85, 0x9b, 0xb3,
-	0x73, 0x98, 0xef, 0xf7, 0x79, 0x98, 0x06, 0xd0, 0xda, 0x0c, 0xb3, 0x54, 0x8a, 0xc4, 0xa8, 0x53,
-	0x1f, 0x05, 0x0d, 0x14, 0xc5, 0x2b, 0x81, 0xc5, 0xf5, 0x23, 0xf7, 0x61, 0x49, 0xa5, 0x51, 0x8f,
-	0xd3, 0xf9, 0x1c, 0x6b, 0x26, 0xdd, 0x87, 0x7a, 0x6f, 0xe0, 0x3f, 0x4f, 0xe2, 0x6c, 0xb2, 0xd0,
-	0xe9, 0xfc, 0x2d, 0x60, 0x57, 0xde, 0x02, 0x6d, 0xfd, 0x16, 0x70, 0xf0, 0x13, 0x8d, 0xef, 0x80,
-	0xb6, 0x7e, 0x07, 0xb8, 0x06, 0xe1, 0x6a, 0xff, 0xae, 0xea, 0x55, 0xa9, 0xa6, 0xf8, 0x3a, 0x0b,
-	0x27, 0xff, 0x90, 0x3a, 0x95, 0x0f, 0xe9, 0x00, 0x56, 0xf5, 0x3e, 0xfb, 0x3f, 0x95, 0xfe, 0x6e,
-	0xc3, 0x2a, 0x13, 0x69, 0xf0, 0x5a, 0xf8, 0x51, 0x2a, 0x93, 0x6c, 0xa8, 0x76, 0x92, 0x92, 0xff,
-	0x36, 0x3e, 0x30, 0xd9, 0x76, 0x98, 0x26, 0xae, 0xd2, 0xe9, 0xe4, 0x11, 0x34, 0xe7, 0x67, 0xf6,
-	0xfc, 0xd5, 0xea, 0x15, 0xf2, 0x08, 0x96, 0x07, 0x71, 0x96, 0x0c, 0x8b, 0xf6, 0xad, 0xec, 0x49,
-	0xed, 0x99, 0x66, 0xb3, 0xfc, 0x1a, 0x79, 0x3a, 0xd7, 0x20, 0x5e, 0x0d, 0xad, 0xbc, 0x5d, 0xca,
-	0xcd, 0xb0, 0xd9, 0x5c, 0x3b, 0x7d, 0x52, 0x9d, 0x45, 0x6f, 0x19, 0x65, 0x6f, 0xcf, 0x7a, 0x68,
-	0x04, 0x2b, 0xf7, 0xe8, 0xaf, 0x16, 0xdc, 0xa8, 0xba, 0x73, 0xa5, 0x21, 0x2e, 0xaa, 0x63, 0x2f,
-	0xac, 0x8e, 0xb3, 0xa8, 0x3a, 0x6e, 0x59, 0x9d, 0xf2, 0x7d, 0xb0, 0x54, 0x79, 0x1f, 0xd0, 0x23,
-	0xb8, 0x7b, 0xae, 0x64, 0x9b, 0xf1, 0x78, 0xa2, 0x7a, 0xe3, 0x3f, 0x94, 0x4e, 0xad, 0xb7, 0x24,
-	0x31, 0x45, 0x6b, 0x30, 0x4d, 0xd0, 0xcf, 0xe0, 0xce, 0x40, 0xc8, 0x4a, 0xc1, 0xf2, 0xce, 0xeb,
-	0x80, 0xb3, 0x23, 0x4e, 0x2e, 0x08, 0x5f, 0xb1, 0xe8, 0x97, 0xe0, 0xed, 0x4d, 0x46, 0x5c, 0x8a,
-	0x6b, 0x49, 0xf7, 0xa0, 0xbe, 0x1b, 0x4f, 0xe2, 0x30, 0x7e, 0x35, 0xbd, 0x64, 0x03, 0x78, 0xb0,
-	0xac, 0x77, 0xb9, 0x5e, 0x29, 0x0d, 0x96, 0x93, 0xf4, 0x96, 0x6a, 0xee, 0x21, 0x0f, 0x87, 0x59,
-	0xa8, 0xdc, 0x50, 0x6f, 0xc7, 0xb4, 0xd7, 0xfe, 0xe3, 0x6c, 0xdd, 0xfa, 0xf3, 0x6c, 0xdd, 0xfa,
-	0xeb, 0x6c, 0xdd, 0x7a, 0xf3, 0xf7, 0xfa, 0x5b, 0x07, 0x35, 0xfc, 0x77, 0x79, 0xf2, 0x4f, 0x00,
-	0x00, 0x00, 0xff, 0xff, 0x4f, 0xa0, 0xa9, 0x8b, 0xcc, 0x0c, 0x00, 0x00,
+	0x18, 0x66, 0x0f, 0x71, 0xec, 0xdf, 0x71, 0x0e, 0xdb, 0x36, 0x6c, 0x0b, 0x0a, 0x66, 0x54, 0x51,
+	0x53, 0x89, 0x50, 0xb5, 0x5c, 0x70, 0xaa, 0x54, 0x1c, 0x87, 0xb2, 0x94, 0x84, 0x32, 0x4e, 0x72,
+	0xc7, 0xc5, 0xc4, 0x1e, 0x35, 0xab, 0xac, 0x77, 0xcc, 0xee, 0x6c, 0x12, 0xf7, 0x82, 0x5b, 0x90,
+	0x78, 0x01, 0x9e, 0xa0, 0xcf, 0xc2, 0x25, 0x8f, 0x80, 0xc2, 0x8b, 0xa0, 0xf9, 0x67, 0xf6, 0x60,
+	0xc7, 0x21, 0x51, 0xe0, 0x6e, 0xfe, 0xd3, 0xf7, 0x9f, 0x7f, 0xaf, 0xa1, 0x35, 0x4e, 0xc2, 0x13,
+	0x26, 0xf9, 0xe6, 0x38, 0x11, 0x52, 0x78, 0xf5, 0x30, 0x96, 0x3c, 0x89, 0x59, 0x44, 0x9e, 0x43,
+	0x23, 0x88, 0x87, 0xfc, 0x6c, 0x87, 0x4b, 0xe6, 0x79, 0xe0, 0xbe, 0xe0, 0x93, 0xd4, 0x77, 0xda,
+	0x56, 0xa7, 0x4e, 0xf1, 0xed, 0x7d, 0x00, 0xcb, 0x7b, 0x09, 0x1b, 0x1c, 0x6f, 0x9f, 0x85, 0xa9,
+	0xe4, 0xf1, 0x80, 0xfb, 0x2e, 0x4a, 0x67, 0xb8, 0xe4, 0x8d, 0x0d, 0x4b, 0x5f, 0x87, 0x3c, 0x1a,
+	0x7e, 0x3f, 0x96, 0xa1, 0x88, 0x53, 0xef, 0x5d, 0x68, 0x6c, 0xb1, 0xc1, 0x11, 0xdf, 0x9b, 0x8c,
+	0x39, 0x22, 0x36, 0x68, 0xc9, 0x28, 0xa4, 0xfd, 0xf0, 0xb5, 0x46, 0x6c, 0xd1, 0x92, 0xe1, 0xb5,
+	0xa1, 0xb9, 0x17, 0x8e, 0xf8, 0x0f, 0x19, 0x8b, 0x65, 0x36, 0xf2, 0x17, 0xd0, 0xba, 0xca, 0x52,
+	0xa1, 0x22, 0x70, 0x1d, 0x45, 0xf8, 0xf6, 0x56, 0xc1, 0xd9, 0x09, 0x63, 0xbf, 0xd1, 0xb6, 0x3a,
+	0x0e, 0x55, 0x4f, 0xe4, 0xb0, 0x33, 0x1f, 0x0c, 0x87, 0x9d, 0x15, 0x29, 0x36, 0xa7, 0x53, 0xdc,
+	0x15, 0x7d, 0xc9, 0xe2, 0x21, 0x4b, 0x86, 0x07, 0x21, 0x3f, 0xf5, 0x97, 0x74, 0x8a, 0xd3, 0x5c,
+	0x65, 0xdb, 0x65, 0x29, 0xf7, 0x5b, 0x08, 0x87, 0x6f, 0xef, 0x1e, 0xd4, 0xbb, 0xa1, 0xec, 0xf1,
+	0xb1, 0x3c, 0xf2, 0x97, 0xdb, 0x56, 0xc7, 0xa5, 0x05, 0xed, 0xdd, 0x86, 0x85, 0xfe, 0x80, 0x45,
+	0xdc, 0x5f, 0x41, 0x03, 0x4d, 0x10, 0x02, 0xcb, 0xc1, 0x68, 0x2c, 0x12, 0x49, 0x79, 0x3a, 0x16,
+	0x71, 0x8a, 0x71, 0x6f, 0x27, 0x89, 0x6f, 0x61, 0x2a, 0xea, 0x49, 0x7e, 0x86, 0xd5, 0x6e, 0x24,
+	0x06, 0xc7, 0x3d, 0x26, 0x19, 0xe5, 0x3f, 0x65, 0x3c, 0x95, 0x0a, 0x0d, 0x3b, 0x65, 0xf4, 0x34,
+	0xa1, 0xb8, 0x58, 0x75, 0xdf, 0xd6, 0x5c, 0x24, 0x14, 0x17, 0xed, 0xb1, 0xee, 0x2e, 0xd5, 0x04,
+	0xc6, 0x73, 0xc4, 0x92, 0x21, 0xd6, 0xdb, 0xa5, 0x9a, 0x50, 0x59, 0x61, 0xce, 0xba, 0xc8, 0xf8,
+	0x26, 0x01, 0xac, 0x55, 0xfc, 0x9b, 0x30, 0xd7, 0xa1, 0x46, 0xc5, 0x69, 0xd0, 0x4b, 0x7d, 0xab,
+	0xed, 0x74, 0x5c, 0x6a, 0x28, 0x6c, 0xa5, 0x88, 0xb2, 0x51, 0xac, 0x44, 0x36, 0x8a, 0x4a, 0x06,
+	0xb9, 0x0b, 0x0b, 0xd8, 0x57, 0x95, 0x65, 0x69, 0xab, 0x9e, 0xe4, 0x17, 0x0b, 0x1a, 0x3b, 0xec,
+	0x0c, 0xc3, 0x48, 0xbd, 0xa7, 0x50, 0xcf, 0xab, 0x8d, 0x4a, 0xcd, 0xc7, 0xef, 0x6f, 0xe6, 0x63,
+	0xba, 0x59, 0xa8, 0x6d, 0xe6, 0x3a, 0xdb, 0xb1, 0x4c, 0x26, 0xb4, 0x30, 0xb9, 0xf7, 0x05, 0xb4,
+	0xa6, 0x44, 0xca, 0xdf, 0x31, 0x9f, 0xe4, 0x55, 0x3d, 0xe6, 0x13, 0x95, 0xff, 0x09, 0x8b, 0x32,
+	0x8e, 0xb5, 0x72, 0xa9, 0x26, 0x3e, 0xb7, 0x3f, 0xb5, 0xc8, 0x01, 0x78, 0x5b, 0x09, 0x67, 0x92,
+	0xa3, 0x93, 0x1d, 0x9e, 0xa6, 0xec, 0x15, 0xbf, 0xbc, 0xe2, 0xba, 0x8a, 0x76, 0xb5, 0x8a, 0x45,
+	0x1f, 0x9c, 0x4a, 0x1f, 0xc8, 0x43, 0xf0, 0x7a, 0x3c, 0xe2, 0x92, 0x9b, 0x1d, 0xfb, 0x17, 0x5c,
+	0xd2, 0xcf, 0x63, 0xb8, 0x5a, 0xd7, 0x7b, 0x00, 0xae, 0x5a, 0x58, 0x0c, 0xa1, 0xf9, 0xf8, 0x56,
+	0x59, 0xa7, 0x62, 0x97, 0x29, 0x2a, 0x90, 0x28, 0x07, 0xc5, 0x78, 0xae, 0x4c, 0x6c, 0xce, 0x28,
+	0x3d, 0x34, 0xae, 0x1c, 0x74, 0xb5, 0x5e, 0xba, 0xaa, 0x2e, 0xbb, 0xf1, 0xf6, 0x2c, 0x4f, 0xf7,
+	0xa6, 0xde, 0xc8, 0x00, 0xde, 0xd1, 0x08, 0x5f, 0x9d, 0xb0, 0x30, 0x62, 0x87, 0xd1, 0x35, 0x3b,
+	0x32, 0x27, 0x70, 0x1f, 0x16, 0xd1, 0x36, 0xe8, 0x99, 0x2d, 0xc8, 0x49, 0xf2, 0xa3, 0xd1, 0x57,
+	0xa3, 0xbf, 0xcb, 0x46, 0xdc, 0xa0, 0xe1, 0xbb, 0xc8, 0xd7, 0xbe, 0x3a, 0x5f, 0xe5, 0x58, 0xad,
+	0x8b, 0x3a, 0x98, 0x8e, 0x72, 0x8c, 0x04, 0x79, 0x02, 0xb5, 0xfe, 0xe0, 0x88, 0x8f, 0x98, 0xf7,
+	0x21, 0x2c, 0x62, 0x84, 0x3c, 0x35, 0x13, 0xbd, 0x32, 0xd3, 0x29, 0x9a, 0xcb, 0x49, 0xcf, 0x64,
+	0x36, 0x37, 0xa6, 0x07, 0x50, 0x43, 0xef, 0xa9, 0xef, 0xce, 0xc2, 0x20, 0x9f, 0x1a, 0x31, 0xd9,
+	0x06, 0x67, 0x9f, 0x06, 0x6a, 0x53, 0x31, 0x82, 0x1c, 0xc5, 0x50, 0x0a, 0xfb, 0x1b, 0x91, 0x4a,
+	0x53, 0x27, 0x7c, 0x2b, 0xde, 0x4b, 0x91, 0x48, 0xac, 0x51, 0x8b, 0xe2, 0x9b, 0xa4, 0xe0, 0xee,
+	0x8a, 0x21, 0xf7, 0x96, 0xc1, 0x0e, 0x7a, 0x06, 0xc3, 0x0e, 0x7a, 0xde, 0x7b, 0x08, 0x6f, 0x4a,
+	0xd3, 0x2a, 0x83, 0xd8, 0xa7, 0x01, 0x45, 0xc7, 0xf7, 0xa1, 0x15, 0xa4, 0x5b, 0x42, 0x24, 0xc3,
+	0x30, 0x66, 0x52, 0x24, 0xe6, 0x97, 0x64, 0x9a, 0x89, 0x1b, 0x24, 0x99, 0xd4, 0x77, 0xbf, 0x41,
+	0x35, 0x41, 0x9e, 0xc1, 0xaa, 0x72, 0x8a, 0x44, 0xde, 0xef, 0x75, 0xa8, 0x29, 0x5e, 0x11, 0x84,
+	0xa1, 0x4a, 0x04, 0xbb, 0x8a, 0xf0, 0x9d, 0x46, 0xd8, 0x3e, 0xe1, 0xb1, 0xac, 0x4c, 0x0c, 0xd2,
+	0x08, 0xd0, 0xa2, 0x9a, 0xf0, 0x88, 0x4e, 0xd0, 0x64, 0xb2, 0x5c, 0x66, 0xa2, 0xb8, 0x14, 0x65,
+	0xe4, 0x37, 0x0b, 0x20, 0x0f, 0x28, 0x4b, 0x0b, 0x13, 0xeb, 0x72, 0x13, 0xaf, 0x93, 0x77, 0xde,
+	0x6c, 0xcb, 0x6a, 0xa9, 0xa5, 0xf9, 0x34, 0x9f, 0x8c, 0x8f, 0xcb, 0xc9, 0xd0, 0x2d, 0xbd, 0x33,
+	0x33, 0x19, 0xda, 0x6b, 0x39, 0x1f, 0x2f, 0xa1, 0x59, 0xe1, 0xcf, 0x9d, 0x92, 0x8f, 0x8a, 0x29,
+	0xb1, 0x67, 0x21, 0x91, 0x6f, 0x20, 0xf3, 0x59, 0x79, 0x01, 0xcd, 0x0a, 0x7b, 0x2e, 0x62, 0x07,
+	0x56, 0xa6, 0xf7, 0x30, 0xbf, 0xef, 0xb3, 0x6c, 0x12, 0x42, 0x6b, 0x2b, 0xca, 0x52, 0xc9, 0x13,
+	0x03, 0xa7, 0x7e, 0x14, 0x34, 0xa3, 0x68, 0x5e, 0xc9, 0x98, 0xdf, 0x3f, 0xef, 0x3e, 0x2c, 0xa8,
+	0x32, 0xea, 0x75, 0xba, 0x58, 0x63, 0x2d, 0x24, 0x07, 0x50, 0xef, 0xf6, 0x83, 0xe7, 0x89, 0xc8,
+	0xc6, 0x73, 0x83, 0xce, 0xbf, 0x0c, 0xec, 0x8b, 0x5f, 0x06, 0xce, 0x85, 0x2f, 0x03, 0xb7, 0xf8,
+	0x32, 0x20, 0x7d, 0x58, 0xd3, 0xa7, 0x52, 0x6d, 0xf1, 0x4d, 0x0e, 0x4e, 0xfe, 0x43, 0xea, 0x54,
+	0x7e, 0x48, 0xfb, 0xb0, 0xa6, 0xef, 0xd9, 0xff, 0x09, 0xfa, 0xc6, 0x86, 0x35, 0xca, 0xd3, 0xf0,
+	0x35, 0x0f, 0xe2, 0x54, 0x26, 0xd9, 0x40, 0xdd, 0x24, 0x65, 0xff, 0xad, 0x38, 0x34, 0xd5, 0x76,
+	0xa8, 0x26, 0xae, 0x33, 0xe9, 0xde, 0x23, 0x68, 0xce, 0xee, 0xec, 0x45, 0xd5, 0xaa, 0x8a, 0xf7,
+	0x08, 0x16, 0xfb, 0x22, 0x4b, 0x06, 0xc5, 0xf8, 0x56, 0xee, 0xa4, 0x8e, 0x4c, 0x8b, 0x69, 0xae,
+	0xe6, 0x3d, 0x9d, 0x19, 0x10, 0xbf, 0x86, 0x5e, 0xde, 0x2e, 0xed, 0xa6, 0xc4, 0x74, 0x66, 0x9c,
+	0x3e, 0xa9, 0xee, 0xa2, 0xbf, 0x88, 0xb6, 0xb7, 0xa7, 0x23, 0x34, 0x86, 0x15, 0x3d, 0xf2, 0xab,
+	0x05, 0x4b, 0xd5, 0x70, 0xae, 0xb5, 0xc4, 0x45, 0x77, 0xec, 0xb9, 0xdd, 0x71, 0xe6, 0x75, 0xc7,
+	0x2d, 0xbb, 0x53, 0x7e, 0x1f, 0x2c, 0x54, 0xbe, 0x0f, 0xc8, 0x31, 0xdc, 0xbd, 0xd0, 0xb2, 0x2d,
+	0x31, 0x1a, 0xab, 0xd9, 0xf8, 0x0f, 0xad, 0x53, 0xe7, 0x2d, 0x49, 0x4c, 0xd3, 0x1a, 0x54, 0x13,
+	0xe4, 0x33, 0xb8, 0xd3, 0xe7, 0xb2, 0xd2, 0xb0, 0x7c, 0xf2, 0xda, 0xe0, 0xec, 0xf2, 0xd3, 0x4b,
+	0xd2, 0x57, 0x22, 0xf2, 0x25, 0xf8, 0xfb, 0xe3, 0x21, 0x93, 0xfc, 0x46, 0xd6, 0x5d, 0xa8, 0xef,
+	0x89, 0xb1, 0x88, 0xc4, 0xab, 0xc9, 0x15, 0x17, 0xc0, 0x87, 0x45, 0x7d, 0xcb, 0xf5, 0x49, 0x69,
+	0xd0, 0x9c, 0x24, 0xb7, 0xd4, 0x70, 0x0f, 0x58, 0x34, 0xc8, 0x22, 0x15, 0x86, 0xfa, 0x76, 0x4c,
+	0xbb, 0xab, 0x7f, 0x9c, 0x6f, 0x58, 0x7f, 0x9e, 0x6f, 0x58, 0x7f, 0x9d, 0x6f, 0x58, 0xbf, 0xff,
+	0xbd, 0xf1, 0xd6, 0x61, 0x0d, 0xff, 0xc9, 0x3c, 0xf9, 0x27, 0x00, 0x00, 0xff, 0xff, 0xb4, 0x70,
+	0x9a, 0xfe, 0xda, 0x0c, 0x00, 0x00,
 }
diff --git a/internal/private.proto b/internal/private.proto
index a327b835e..d36527f63 100644
--- a/internal/private.proto
+++ b/internal/private.proto
@@ -18,6 +18,7 @@ message FieldOptions {
 	bool NoStandardView = 12;
 	int64 Base = 13;
 	uint64 BitDepth = 14;
+	int64 Scale = 15;
 }
 
 message ImportResponse {
diff --git a/internal/public.pb.go b/internal/public.pb.go
index 708d43e2f..e376346bb 100644
--- a/internal/public.pb.go
+++ b/internal/public.pb.go
@@ -1,39 +1,13 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: public.proto
 
-/*
-	Package internal is a generated protocol buffer package.
-
-	It is generated from these files:
-		public.proto
-
-	It has these top-level messages:
-		Row
-		RowIdentifiers
-		Pair
-		FieldRow
-		GroupCount
-		ValCount
-		ColumnAttrSet
-		Attr
-		AttrMap
-		QueryRequest
-		QueryResponse
-		QueryResult
-		ImportRequest
-		ImportValueRequest
-		TranslateKeysRequest
-		TranslateKeysResponse
-		ImportRoaringRequestView
-		ImportRoaringRequest
-*/
 package internal
 
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
 import math "math"
 
-import binary "encoding/binary"
+import encoding_binary "encoding/binary"
 
 import io "io"
 
@@ -49,15 +23,46 @@ var _ = math.Inf
 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 
 type Row struct {
-	Columns []uint64 `protobuf:"varint,1,rep,packed,name=Columns" json:"Columns,omitempty"`
-	Keys    []string `protobuf:"bytes,3,rep,name=Keys" json:"Keys,omitempty"`
-	Attrs   []*Attr  `protobuf:"bytes,2,rep,name=Attrs" json:"Attrs,omitempty"`
+	Columns              []uint64 `protobuf:"varint,1,rep,packed,name=Columns" json:"Columns,omitempty"`
+	Keys                 []string `protobuf:"bytes,3,rep,name=Keys" json:"Keys,omitempty"`
+	Attrs                []*Attr  `protobuf:"bytes,2,rep,name=Attrs" json:"Attrs,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *Row) Reset()                    { *m = Row{} }
-func (m *Row) String() string            { return proto.CompactTextString(m) }
-func (*Row) ProtoMessage()               {}
-func (*Row) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{0} }
+func (m *Row) Reset()         { *m = Row{} }
+func (m *Row) String() string { return proto.CompactTextString(m) }
+func (*Row) ProtoMessage()    {}
+func (*Row) Descriptor() ([]byte, []int) {
+	return fileDescriptor_public_6f31a3d3ed4c07fc, []int{0}
+}
+func (m *Row) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Row) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Row.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *Row) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Row.Merge(dst, src)
+}
+func (m *Row) XXX_Size() int {
+	return m.Size()
+}
+func (m *Row) XXX_DiscardUnknown() {
+	xxx_messageInfo_Row.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Row proto.InternalMessageInfo
 
 func (m *Row) GetColumns() []uint64 {
 	if m != nil {
@@ -81,14 +86,45 @@ func (m *Row) GetAttrs() []*Attr {
 }
 
 type RowIdentifiers struct {
-	Rows []uint64 `protobuf:"varint,1,rep,packed,name=Rows" json:"Rows,omitempty"`
-	Keys []string `protobuf:"bytes,2,rep,name=Keys" json:"Keys,omitempty"`
+	Rows                 []uint64 `protobuf:"varint,1,rep,packed,name=Rows" json:"Rows,omitempty"`
+	Keys                 []string `protobuf:"bytes,2,rep,name=Keys" json:"Keys,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *RowIdentifiers) Reset()                    { *m = RowIdentifiers{} }
-func (m *RowIdentifiers) String() string            { return proto.CompactTextString(m) }
-func (*RowIdentifiers) ProtoMessage()               {}
-func (*RowIdentifiers) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{1} }
+func (m *RowIdentifiers) Reset()         { *m = RowIdentifiers{} }
+func (m *RowIdentifiers) String() string { return proto.CompactTextString(m) }
+func (*RowIdentifiers) ProtoMessage()    {}
+func (*RowIdentifiers) Descriptor() ([]byte, []int) {
+	return fileDescriptor_public_6f31a3d3ed4c07fc, []int{1}
+}
+func (m *RowIdentifiers) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *RowIdentifiers) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_RowIdentifiers.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *RowIdentifiers) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RowIdentifiers.Merge(dst, src)
+}
+func (m *RowIdentifiers) XXX_Size() int {
+	return m.Size()
+}
+func (m *RowIdentifiers) XXX_DiscardUnknown() {
+	xxx_messageInfo_RowIdentifiers.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RowIdentifiers proto.InternalMessageInfo
 
 func (m *RowIdentifiers) GetRows() []uint64 {
 	if m != nil {
@@ -105,15 +141,46 @@ func (m *RowIdentifiers) GetKeys() []string {
 }
 
 type Pair struct {
-	ID    uint64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
-	Key   string `protobuf:"bytes,3,opt,name=Key,proto3" json:"Key,omitempty"`
-	Count uint64 `protobuf:"varint,2,opt,name=Count,proto3" json:"Count,omitempty"`
+	ID                   uint64   `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
+	Key                  string   `protobuf:"bytes,3,opt,name=Key,proto3" json:"Key,omitempty"`
+	Count                uint64   `protobuf:"varint,2,opt,name=Count,proto3" json:"Count,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *Pair) Reset()                    { *m = Pair{} }
-func (m *Pair) String() string            { return proto.CompactTextString(m) }
-func (*Pair) ProtoMessage()               {}
-func (*Pair) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{2} }
+func (m *Pair) Reset()         { *m = Pair{} }
+func (m *Pair) String() string { return proto.CompactTextString(m) }
+func (*Pair) ProtoMessage()    {}
+func (*Pair) Descriptor() ([]byte, []int) {
+	return fileDescriptor_public_6f31a3d3ed4c07fc, []int{2}
+}
+func (m *Pair) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Pair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Pair.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *Pair) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Pair.Merge(dst, src)
+}
+func (m *Pair) XXX_Size() int {
+	return m.Size()
+}
+func (m *Pair) XXX_DiscardUnknown() {
+	xxx_messageInfo_Pair.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Pair proto.InternalMessageInfo
 
 func (m *Pair) GetID() uint64 {
 	if m != nil {
@@ -137,15 +204,46 @@ func (m *Pair) GetCount() uint64 {
 }
 
 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"`
+	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"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *FieldRow) Reset()                    { *m = FieldRow{} }
-func (m *FieldRow) String() string            { return proto.CompactTextString(m) }
-func (*FieldRow) ProtoMessage()               {}
-func (*FieldRow) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{3} }
+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_public_6f31a3d3ed4c07fc, []int{3}
+}
+func (m *FieldRow) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *FieldRow) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_FieldRow.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *FieldRow) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FieldRow.Merge(dst, src)
+}
+func (m *FieldRow) XXX_Size() int {
+	return m.Size()
+}
+func (m *FieldRow) XXX_DiscardUnknown() {
+	xxx_messageInfo_FieldRow.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FieldRow proto.InternalMessageInfo
 
 func (m *FieldRow) GetField() string {
 	if m != nil {
@@ -169,14 +267,45 @@ func (m *FieldRow) GetRowKey() string {
 }
 
 type GroupCount struct {
-	Group []*FieldRow `protobuf:"bytes,1,rep,name=Group" json:"Group,omitempty"`
-	Count uint64      `protobuf:"varint,2,opt,name=Count,proto3" json:"Count,omitempty"`
+	Group                []*FieldRow `protobuf:"bytes,1,rep,name=Group" json:"Group,omitempty"`
+	Count                uint64      `protobuf:"varint,2,opt,name=Count,proto3" json:"Count,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
 }
 
-func (m *GroupCount) Reset()                    { *m = GroupCount{} }
-func (m *GroupCount) String() string            { return proto.CompactTextString(m) }
-func (*GroupCount) ProtoMessage()               {}
-func (*GroupCount) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{4} }
+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_public_6f31a3d3ed4c07fc, []int{4}
+}
+func (m *GroupCount) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *GroupCount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_GroupCount.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *GroupCount) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GroupCount.Merge(dst, src)
+}
+func (m *GroupCount) XXX_Size() int {
+	return m.Size()
+}
+func (m *GroupCount) XXX_DiscardUnknown() {
+	xxx_messageInfo_GroupCount.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GroupCount proto.InternalMessageInfo
 
 func (m *GroupCount) GetGroup() []*FieldRow {
 	if m != nil {
@@ -193,14 +322,45 @@ func (m *GroupCount) GetCount() uint64 {
 }
 
 type ValCount struct {
-	Val   int64 `protobuf:"varint,1,opt,name=Val,proto3" json:"Val,omitempty"`
-	Count int64 `protobuf:"varint,2,opt,name=Count,proto3" json:"Count,omitempty"`
+	Val                  int64    `protobuf:"varint,1,opt,name=Val,proto3" json:"Val,omitempty"`
+	Count                int64    `protobuf:"varint,2,opt,name=Count,proto3" json:"Count,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *ValCount) Reset()                    { *m = ValCount{} }
-func (m *ValCount) String() string            { return proto.CompactTextString(m) }
-func (*ValCount) ProtoMessage()               {}
-func (*ValCount) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{5} }
+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_public_6f31a3d3ed4c07fc, []int{5}
+}
+func (m *ValCount) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ValCount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ValCount.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *ValCount) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ValCount.Merge(dst, src)
+}
+func (m *ValCount) XXX_Size() int {
+	return m.Size()
+}
+func (m *ValCount) XXX_DiscardUnknown() {
+	xxx_messageInfo_ValCount.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ValCount proto.InternalMessageInfo
 
 func (m *ValCount) GetVal() int64 {
 	if m != nil {
@@ -217,15 +377,46 @@ func (m *ValCount) GetCount() int64 {
 }
 
 type ColumnAttrSet struct {
-	ID    uint64  `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
-	Key   string  `protobuf:"bytes,3,opt,name=Key,proto3" json:"Key,omitempty"`
-	Attrs []*Attr `protobuf:"bytes,2,rep,name=Attrs" json:"Attrs,omitempty"`
+	ID                   uint64   `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
+	Key                  string   `protobuf:"bytes,3,opt,name=Key,proto3" json:"Key,omitempty"`
+	Attrs                []*Attr  `protobuf:"bytes,2,rep,name=Attrs" json:"Attrs,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *ColumnAttrSet) Reset()                    { *m = ColumnAttrSet{} }
-func (m *ColumnAttrSet) String() string            { return proto.CompactTextString(m) }
-func (*ColumnAttrSet) ProtoMessage()               {}
-func (*ColumnAttrSet) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{6} }
+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_public_6f31a3d3ed4c07fc, []int{6}
+}
+func (m *ColumnAttrSet) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ColumnAttrSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ColumnAttrSet.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *ColumnAttrSet) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ColumnAttrSet.Merge(dst, src)
+}
+func (m *ColumnAttrSet) XXX_Size() int {
+	return m.Size()
+}
+func (m *ColumnAttrSet) XXX_DiscardUnknown() {
+	xxx_messageInfo_ColumnAttrSet.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ColumnAttrSet proto.InternalMessageInfo
 
 func (m *ColumnAttrSet) GetID() uint64 {
 	if m != nil {
@@ -249,18 +440,49 @@ func (m *ColumnAttrSet) GetAttrs() []*Attr {
 }
 
 type Attr struct {
-	Key         string  `protobuf:"bytes,1,opt,name=Key,proto3" json:"Key,omitempty"`
-	Type        uint64  `protobuf:"varint,2,opt,name=Type,proto3" json:"Type,omitempty"`
-	StringValue string  `protobuf:"bytes,3,opt,name=StringValue,proto3" json:"StringValue,omitempty"`
-	IntValue    int64   `protobuf:"varint,4,opt,name=IntValue,proto3" json:"IntValue,omitempty"`
-	BoolValue   bool    `protobuf:"varint,5,opt,name=BoolValue,proto3" json:"BoolValue,omitempty"`
-	FloatValue  float64 `protobuf:"fixed64,6,opt,name=FloatValue,proto3" json:"FloatValue,omitempty"`
+	Key                  string   `protobuf:"bytes,1,opt,name=Key,proto3" json:"Key,omitempty"`
+	Type                 uint64   `protobuf:"varint,2,opt,name=Type,proto3" json:"Type,omitempty"`
+	StringValue          string   `protobuf:"bytes,3,opt,name=StringValue,proto3" json:"StringValue,omitempty"`
+	IntValue             int64    `protobuf:"varint,4,opt,name=IntValue,proto3" json:"IntValue,omitempty"`
+	BoolValue            bool     `protobuf:"varint,5,opt,name=BoolValue,proto3" json:"BoolValue,omitempty"`
+	FloatValue           float64  `protobuf:"fixed64,6,opt,name=FloatValue,proto3" json:"FloatValue,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *Attr) Reset()                    { *m = Attr{} }
-func (m *Attr) String() string            { return proto.CompactTextString(m) }
-func (*Attr) ProtoMessage()               {}
-func (*Attr) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{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_public_6f31a3d3ed4c07fc, []int{7}
+}
+func (m *Attr) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Attr) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Attr.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *Attr) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Attr.Merge(dst, src)
+}
+func (m *Attr) XXX_Size() int {
+	return m.Size()
+}
+func (m *Attr) XXX_DiscardUnknown() {
+	xxx_messageInfo_Attr.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Attr proto.InternalMessageInfo
 
 func (m *Attr) GetKey() string {
 	if m != nil {
@@ -305,13 +527,44 @@ func (m *Attr) GetFloatValue() float64 {
 }
 
 type AttrMap struct {
-	Attrs []*Attr `protobuf:"bytes,1,rep,name=Attrs" json:"Attrs,omitempty"`
+	Attrs                []*Attr  `protobuf:"bytes,1,rep,name=Attrs" json:"Attrs,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *AttrMap) Reset()                    { *m = AttrMap{} }
-func (m *AttrMap) String() string            { return proto.CompactTextString(m) }
-func (*AttrMap) ProtoMessage()               {}
-func (*AttrMap) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{8} }
+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_public_6f31a3d3ed4c07fc, []int{8}
+}
+func (m *AttrMap) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *AttrMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_AttrMap.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *AttrMap) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_AttrMap.Merge(dst, src)
+}
+func (m *AttrMap) XXX_Size() int {
+	return m.Size()
+}
+func (m *AttrMap) XXX_DiscardUnknown() {
+	xxx_messageInfo_AttrMap.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AttrMap proto.InternalMessageInfo
 
 func (m *AttrMap) GetAttrs() []*Attr {
 	if m != nil {
@@ -321,18 +574,49 @@ func (m *AttrMap) GetAttrs() []*Attr {
 }
 
 type QueryRequest struct {
-	Query           string   `protobuf:"bytes,1,opt,name=Query,proto3" json:"Query,omitempty"`
-	Shards          []uint64 `protobuf:"varint,2,rep,packed,name=Shards" json:"Shards,omitempty"`
-	ColumnAttrs     bool     `protobuf:"varint,3,opt,name=ColumnAttrs,proto3" json:"ColumnAttrs,omitempty"`
-	Remote          bool     `protobuf:"varint,5,opt,name=Remote,proto3" json:"Remote,omitempty"`
-	ExcludeRowAttrs bool     `protobuf:"varint,6,opt,name=ExcludeRowAttrs,proto3" json:"ExcludeRowAttrs,omitempty"`
-	ExcludeColumns  bool     `protobuf:"varint,7,opt,name=ExcludeColumns,proto3" json:"ExcludeColumns,omitempty"`
+	Query                string   `protobuf:"bytes,1,opt,name=Query,proto3" json:"Query,omitempty"`
+	Shards               []uint64 `protobuf:"varint,2,rep,packed,name=Shards" json:"Shards,omitempty"`
+	ColumnAttrs          bool     `protobuf:"varint,3,opt,name=ColumnAttrs,proto3" json:"ColumnAttrs,omitempty"`
+	Remote               bool     `protobuf:"varint,5,opt,name=Remote,proto3" json:"Remote,omitempty"`
+	ExcludeRowAttrs      bool     `protobuf:"varint,6,opt,name=ExcludeRowAttrs,proto3" json:"ExcludeRowAttrs,omitempty"`
+	ExcludeColumns       bool     `protobuf:"varint,7,opt,name=ExcludeColumns,proto3" json:"ExcludeColumns,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *QueryRequest) Reset()                    { *m = QueryRequest{} }
-func (m *QueryRequest) String() string            { return proto.CompactTextString(m) }
-func (*QueryRequest) ProtoMessage()               {}
-func (*QueryRequest) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{9} }
+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_public_6f31a3d3ed4c07fc, []int{9}
+}
+func (m *QueryRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *QueryRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryRequest.Merge(dst, src)
+}
+func (m *QueryRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryRequest proto.InternalMessageInfo
 
 func (m *QueryRequest) GetQuery() string {
 	if m != nil {
@@ -377,15 +661,46 @@ func (m *QueryRequest) GetExcludeColumns() bool {
 }
 
 type QueryResponse struct {
-	Err            string           `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
-	Results        []*QueryResult   `protobuf:"bytes,2,rep,name=Results" json:"Results,omitempty"`
-	ColumnAttrSets []*ColumnAttrSet `protobuf:"bytes,3,rep,name=ColumnAttrSets" json:"ColumnAttrSets,omitempty"`
+	Err                  string           `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
+	Results              []*QueryResult   `protobuf:"bytes,2,rep,name=Results" json:"Results,omitempty"`
+	ColumnAttrSets       []*ColumnAttrSet `protobuf:"bytes,3,rep,name=ColumnAttrSets" json:"ColumnAttrSets,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
 }
 
-func (m *QueryResponse) Reset()                    { *m = QueryResponse{} }
-func (m *QueryResponse) String() string            { return proto.CompactTextString(m) }
-func (*QueryResponse) ProtoMessage()               {}
-func (*QueryResponse) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{10} }
+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_public_6f31a3d3ed4c07fc, []int{10}
+}
+func (m *QueryResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *QueryResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryResponse.Merge(dst, src)
+}
+func (m *QueryResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryResponse proto.InternalMessageInfo
 
 func (m *QueryResponse) GetErr() string {
 	if m != nil {
@@ -409,21 +724,52 @@ func (m *QueryResponse) GetColumnAttrSets() []*ColumnAttrSet {
 }
 
 type QueryResult struct {
-	Type           uint32          `protobuf:"varint,6,opt,name=Type,proto3" json:"Type,omitempty"`
-	Row            *Row            `protobuf:"bytes,1,opt,name=Row" json:"Row,omitempty"`
-	N              uint64          `protobuf:"varint,2,opt,name=N,proto3" json:"N,omitempty"`
-	Pairs          []*Pair         `protobuf:"bytes,3,rep,name=Pairs" json:"Pairs,omitempty"`
-	Changed        bool            `protobuf:"varint,4,opt,name=Changed,proto3" json:"Changed,omitempty"`
-	ValCount       *ValCount       `protobuf:"bytes,5,opt,name=ValCount" json:"ValCount,omitempty"`
-	RowIDs         []uint64        `protobuf:"varint,7,rep,packed,name=RowIDs" json:"RowIDs,omitempty"`
-	GroupCounts    []*GroupCount   `protobuf:"bytes,8,rep,name=GroupCounts" json:"GroupCounts,omitempty"`
-	RowIdentifiers *RowIdentifiers `protobuf:"bytes,9,opt,name=RowIdentifiers" json:"RowIdentifiers,omitempty"`
+	Type                 uint32          `protobuf:"varint,6,opt,name=Type,proto3" json:"Type,omitempty"`
+	Row                  *Row            `protobuf:"bytes,1,opt,name=Row" json:"Row,omitempty"`
+	N                    uint64          `protobuf:"varint,2,opt,name=N,proto3" json:"N,omitempty"`
+	Pairs                []*Pair         `protobuf:"bytes,3,rep,name=Pairs" json:"Pairs,omitempty"`
+	Changed              bool            `protobuf:"varint,4,opt,name=Changed,proto3" json:"Changed,omitempty"`
+	ValCount             *ValCount       `protobuf:"bytes,5,opt,name=ValCount" json:"ValCount,omitempty"`
+	RowIDs               []uint64        `protobuf:"varint,7,rep,packed,name=RowIDs" json:"RowIDs,omitempty"`
+	GroupCounts          []*GroupCount   `protobuf:"bytes,8,rep,name=GroupCounts" json:"GroupCounts,omitempty"`
+	RowIdentifiers       *RowIdentifiers `protobuf:"bytes,9,opt,name=RowIdentifiers" json:"RowIdentifiers,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+	XXX_unrecognized     []byte          `json:"-"`
+	XXX_sizecache        int32           `json:"-"`
 }
 
-func (m *QueryResult) Reset()                    { *m = QueryResult{} }
-func (m *QueryResult) String() string            { return proto.CompactTextString(m) }
-func (*QueryResult) ProtoMessage()               {}
-func (*QueryResult) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{11} }
+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_public_6f31a3d3ed4c07fc, []int{11}
+}
+func (m *QueryResult) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryResult.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *QueryResult) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryResult.Merge(dst, src)
+}
+func (m *QueryResult) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryResult) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryResult.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryResult proto.InternalMessageInfo
 
 func (m *QueryResult) GetType() uint32 {
 	if m != nil {
@@ -489,20 +835,51 @@ func (m *QueryResult) GetRowIdentifiers() *RowIdentifiers {
 }
 
 type ImportRequest struct {
-	Index      string   `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
-	Field      string   `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
-	Shard      uint64   `protobuf:"varint,3,opt,name=Shard,proto3" json:"Shard,omitempty"`
-	RowIDs     []uint64 `protobuf:"varint,4,rep,packed,name=RowIDs" json:"RowIDs,omitempty"`
-	ColumnIDs  []uint64 `protobuf:"varint,5,rep,packed,name=ColumnIDs" json:"ColumnIDs,omitempty"`
-	RowKeys    []string `protobuf:"bytes,7,rep,name=RowKeys" json:"RowKeys,omitempty"`
-	ColumnKeys []string `protobuf:"bytes,8,rep,name=ColumnKeys" json:"ColumnKeys,omitempty"`
-	Timestamps []int64  `protobuf:"varint,6,rep,packed,name=Timestamps" json:"Timestamps,omitempty"`
+	Index                string   `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
+	Field                string   `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
+	Shard                uint64   `protobuf:"varint,3,opt,name=Shard,proto3" json:"Shard,omitempty"`
+	RowIDs               []uint64 `protobuf:"varint,4,rep,packed,name=RowIDs" json:"RowIDs,omitempty"`
+	ColumnIDs            []uint64 `protobuf:"varint,5,rep,packed,name=ColumnIDs" json:"ColumnIDs,omitempty"`
+	RowKeys              []string `protobuf:"bytes,7,rep,name=RowKeys" json:"RowKeys,omitempty"`
+	ColumnKeys           []string `protobuf:"bytes,8,rep,name=ColumnKeys" json:"ColumnKeys,omitempty"`
+	Timestamps           []int64  `protobuf:"varint,6,rep,packed,name=Timestamps" json:"Timestamps,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *ImportRequest) Reset()                    { *m = ImportRequest{} }
-func (m *ImportRequest) String() string            { return proto.CompactTextString(m) }
-func (*ImportRequest) ProtoMessage()               {}
-func (*ImportRequest) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{12} }
+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_public_6f31a3d3ed4c07fc, []int{12}
+}
+func (m *ImportRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ImportRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ImportRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *ImportRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ImportRequest.Merge(dst, src)
+}
+func (m *ImportRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *ImportRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_ImportRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ImportRequest proto.InternalMessageInfo
 
 func (m *ImportRequest) GetIndex() string {
 	if m != nil {
@@ -561,18 +938,50 @@ func (m *ImportRequest) GetTimestamps() []int64 {
 }
 
 type ImportValueRequest struct {
-	Index      string   `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
-	Field      string   `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
-	Shard      uint64   `protobuf:"varint,3,opt,name=Shard,proto3" json:"Shard,omitempty"`
-	ColumnIDs  []uint64 `protobuf:"varint,5,rep,packed,name=ColumnIDs" json:"ColumnIDs,omitempty"`
-	ColumnKeys []string `protobuf:"bytes,7,rep,name=ColumnKeys" json:"ColumnKeys,omitempty"`
-	Values     []int64  `protobuf:"varint,6,rep,packed,name=Values" json:"Values,omitempty"`
+	Index                string    `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
+	Field                string    `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
+	Shard                uint64    `protobuf:"varint,3,opt,name=Shard,proto3" json:"Shard,omitempty"`
+	ColumnIDs            []uint64  `protobuf:"varint,5,rep,packed,name=ColumnIDs" json:"ColumnIDs,omitempty"`
+	ColumnKeys           []string  `protobuf:"bytes,7,rep,name=ColumnKeys" json:"ColumnKeys,omitempty"`
+	Values               []int64   `protobuf:"varint,6,rep,packed,name=Values" json:"Values,omitempty"`
+	FloatValues          []float64 `protobuf:"fixed64,8,rep,packed,name=FloatValues" json:"FloatValues,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
+	XXX_unrecognized     []byte    `json:"-"`
+	XXX_sizecache        int32     `json:"-"`
 }
 
-func (m *ImportValueRequest) Reset()                    { *m = ImportValueRequest{} }
-func (m *ImportValueRequest) String() string            { return proto.CompactTextString(m) }
-func (*ImportValueRequest) ProtoMessage()               {}
-func (*ImportValueRequest) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{13} }
+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_public_6f31a3d3ed4c07fc, []int{13}
+}
+func (m *ImportValueRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ImportValueRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ImportValueRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *ImportValueRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ImportValueRequest.Merge(dst, src)
+}
+func (m *ImportValueRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *ImportValueRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_ImportValueRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ImportValueRequest proto.InternalMessageInfo
 
 func (m *ImportValueRequest) GetIndex() string {
 	if m != nil {
@@ -616,16 +1025,54 @@ func (m *ImportValueRequest) GetValues() []int64 {
 	return nil
 }
 
-type TranslateKeysRequest struct {
-	Index string   `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
-	Field string   `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
-	Keys  []string `protobuf:"bytes,3,rep,name=Keys" json:"Keys,omitempty"`
+func (m *ImportValueRequest) GetFloatValues() []float64 {
+	if m != nil {
+		return m.FloatValues
+	}
+	return nil
 }
 
-func (m *TranslateKeysRequest) Reset()                    { *m = TranslateKeysRequest{} }
-func (m *TranslateKeysRequest) String() string            { return proto.CompactTextString(m) }
-func (*TranslateKeysRequest) ProtoMessage()               {}
-func (*TranslateKeysRequest) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{14} }
+type TranslateKeysRequest struct {
+	Index                string   `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
+	Field                string   `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
+	Keys                 []string `protobuf:"bytes,3,rep,name=Keys" json:"Keys,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+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_public_6f31a3d3ed4c07fc, []int{14}
+}
+func (m *TranslateKeysRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *TranslateKeysRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_TranslateKeysRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *TranslateKeysRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TranslateKeysRequest.Merge(dst, src)
+}
+func (m *TranslateKeysRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *TranslateKeysRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_TranslateKeysRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TranslateKeysRequest proto.InternalMessageInfo
 
 func (m *TranslateKeysRequest) GetIndex() string {
 	if m != nil {
@@ -649,13 +1096,44 @@ func (m *TranslateKeysRequest) GetKeys() []string {
 }
 
 type TranslateKeysResponse struct {
-	IDs []uint64 `protobuf:"varint,3,rep,packed,name=IDs" json:"IDs,omitempty"`
+	IDs                  []uint64 `protobuf:"varint,3,rep,packed,name=IDs" json:"IDs,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *TranslateKeysResponse) Reset()                    { *m = TranslateKeysResponse{} }
-func (m *TranslateKeysResponse) String() string            { return proto.CompactTextString(m) }
-func (*TranslateKeysResponse) ProtoMessage()               {}
-func (*TranslateKeysResponse) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{15} }
+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_public_6f31a3d3ed4c07fc, []int{15}
+}
+func (m *TranslateKeysResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *TranslateKeysResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_TranslateKeysResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *TranslateKeysResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TranslateKeysResponse.Merge(dst, src)
+}
+func (m *TranslateKeysResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *TranslateKeysResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_TranslateKeysResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TranslateKeysResponse proto.InternalMessageInfo
 
 func (m *TranslateKeysResponse) GetIDs() []uint64 {
 	if m != nil {
@@ -665,14 +1143,45 @@ func (m *TranslateKeysResponse) GetIDs() []uint64 {
 }
 
 type ImportRoaringRequestView struct {
-	Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
-	Data []byte `protobuf:"bytes,2,opt,name=Data,proto3" json:"Data,omitempty"`
+	Name                 string   `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
+	Data                 []byte   `protobuf:"bytes,2,opt,name=Data,proto3" json:"Data,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *ImportRoaringRequestView) Reset()                    { *m = ImportRoaringRequestView{} }
-func (m *ImportRoaringRequestView) String() string            { return proto.CompactTextString(m) }
-func (*ImportRoaringRequestView) ProtoMessage()               {}
-func (*ImportRoaringRequestView) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{16} }
+func (m *ImportRoaringRequestView) Reset()         { *m = ImportRoaringRequestView{} }
+func (m *ImportRoaringRequestView) String() string { return proto.CompactTextString(m) }
+func (*ImportRoaringRequestView) ProtoMessage()    {}
+func (*ImportRoaringRequestView) Descriptor() ([]byte, []int) {
+	return fileDescriptor_public_6f31a3d3ed4c07fc, []int{16}
+}
+func (m *ImportRoaringRequestView) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ImportRoaringRequestView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ImportRoaringRequestView.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *ImportRoaringRequestView) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ImportRoaringRequestView.Merge(dst, src)
+}
+func (m *ImportRoaringRequestView) XXX_Size() int {
+	return m.Size()
+}
+func (m *ImportRoaringRequestView) XXX_DiscardUnknown() {
+	xxx_messageInfo_ImportRoaringRequestView.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ImportRoaringRequestView proto.InternalMessageInfo
 
 func (m *ImportRoaringRequestView) GetName() string {
 	if m != nil {
@@ -689,14 +1198,45 @@ func (m *ImportRoaringRequestView) GetData() []byte {
 }
 
 type ImportRoaringRequest struct {
-	Clear bool                        `protobuf:"varint,1,opt,name=Clear,proto3" json:"Clear,omitempty"`
-	Views []*ImportRoaringRequestView `protobuf:"bytes,2,rep,name=views" json:"views,omitempty"`
+	Clear                bool                        `protobuf:"varint,1,opt,name=Clear,proto3" json:"Clear,omitempty"`
+	Views                []*ImportRoaringRequestView `protobuf:"bytes,2,rep,name=views" json:"views,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
+	XXX_unrecognized     []byte                      `json:"-"`
+	XXX_sizecache        int32                       `json:"-"`
 }
 
-func (m *ImportRoaringRequest) Reset()                    { *m = ImportRoaringRequest{} }
-func (m *ImportRoaringRequest) String() string            { return proto.CompactTextString(m) }
-func (*ImportRoaringRequest) ProtoMessage()               {}
-func (*ImportRoaringRequest) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{17} }
+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_public_6f31a3d3ed4c07fc, []int{17}
+}
+func (m *ImportRoaringRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ImportRoaringRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ImportRoaringRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (dst *ImportRoaringRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ImportRoaringRequest.Merge(dst, src)
+}
+func (m *ImportRoaringRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *ImportRoaringRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_ImportRoaringRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ImportRoaringRequest proto.InternalMessageInfo
 
 func (m *ImportRoaringRequest) GetClear() bool {
 	if m != nil {
@@ -791,6 +1331,9 @@ func (m *Row) MarshalTo(dAtA []byte) (int, error) {
 			i += copy(dAtA[i:], s)
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -841,6 +1384,9 @@ func (m *RowIdentifiers) MarshalTo(dAtA []byte) (int, error) {
 			i += copy(dAtA[i:], s)
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -875,6 +1421,9 @@ func (m *Pair) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPublic(dAtA, i, uint64(len(m.Key)))
 		i += copy(dAtA[i:], m.Key)
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -910,6 +1459,9 @@ func (m *FieldRow) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPublic(dAtA, i, uint64(len(m.RowKey)))
 		i += copy(dAtA[i:], m.RowKey)
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -945,6 +1497,9 @@ func (m *GroupCount) MarshalTo(dAtA []byte) (int, error) {
 		i++
 		i = encodeVarintPublic(dAtA, i, uint64(m.Count))
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -973,6 +1528,9 @@ func (m *ValCount) MarshalTo(dAtA []byte) (int, error) {
 		i++
 		i = encodeVarintPublic(dAtA, i, uint64(m.Count))
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1014,6 +1572,9 @@ func (m *ColumnAttrSet) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPublic(dAtA, i, uint64(len(m.Key)))
 		i += copy(dAtA[i:], m.Key)
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1067,9 +1628,12 @@ func (m *Attr) MarshalTo(dAtA []byte) (int, error) {
 	if m.FloatValue != 0 {
 		dAtA[i] = 0x31
 		i++
-		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.FloatValue))))
+		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.FloatValue))))
 		i += 8
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1100,6 +1664,9 @@ func (m *AttrMap) MarshalTo(dAtA []byte) (int, error) {
 			i += n
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1181,6 +1748,9 @@ func (m *QueryRequest) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i++
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1229,6 +1799,9 @@ func (m *QueryResponse) MarshalTo(dAtA []byte) (int, error) {
 			i += n
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1338,6 +1911,9 @@ func (m *QueryResult) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i += n11
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1455,6 +2031,9 @@ func (m *ImportRequest) MarshalTo(dAtA []byte) (int, error) {
 			i += copy(dAtA[i:], s)
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1540,6 +2119,19 @@ func (m *ImportValueRequest) MarshalTo(dAtA []byte) (int, error) {
 			i += copy(dAtA[i:], s)
 		}
 	}
+	if len(m.FloatValues) > 0 {
+		dAtA[i] = 0x42
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.FloatValues)*8))
+		for _, num := range m.FloatValues {
+			f22 := math.Float64bits(float64(num))
+			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f22))
+			i += 8
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1585,6 +2177,9 @@ func (m *TranslateKeysRequest) MarshalTo(dAtA []byte) (int, error) {
 			i += copy(dAtA[i:], s)
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1604,21 +2199,24 @@ func (m *TranslateKeysResponse) MarshalTo(dAtA []byte) (int, error) {
 	var l int
 	_ = l
 	if len(m.IDs) > 0 {
-		dAtA23 := make([]byte, len(m.IDs)*10)
-		var j22 int
+		dAtA24 := make([]byte, len(m.IDs)*10)
+		var j23 int
 		for _, num := range m.IDs {
 			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++
 		}
 		dAtA[i] = 0x1a
 		i++
-		i = encodeVarintPublic(dAtA, i, uint64(j22))
-		i += copy(dAtA[i:], dAtA23[:j22])
+		i = encodeVarintPublic(dAtA, i, uint64(j23))
+		i += copy(dAtA[i:], dAtA24[:j23])
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	return i, nil
 }
@@ -1650,6 +2248,9 @@ func (m *ImportRoaringRequestView) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintPublic(dAtA, i, uint64(len(m.Data)))
 		i += copy(dAtA[i:], m.Data)
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1690,6 +2291,9 @@ func (m *ImportRoaringRequest) MarshalTo(dAtA []byte) (int, error) {
 			i += n
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1703,6 +2307,9 @@ func encodeVarintPublic(dAtA []byte, offset int, v uint64) int {
 	return offset + 1
 }
 func (m *Row) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	if len(m.Columns) > 0 {
@@ -1724,10 +2331,16 @@ func (m *Row) Size() (n int) {
 			n += 1 + l + sovPublic(uint64(l))
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *RowIdentifiers) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	if len(m.Rows) > 0 {
@@ -1743,10 +2356,16 @@ func (m *RowIdentifiers) Size() (n int) {
 			n += 1 + l + sovPublic(uint64(l))
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *Pair) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	if m.ID != 0 {
@@ -1759,10 +2378,16 @@ func (m *Pair) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPublic(uint64(l))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *FieldRow) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Field)
@@ -1776,10 +2401,16 @@ func (m *FieldRow) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPublic(uint64(l))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *GroupCount) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	if len(m.Group) > 0 {
@@ -1791,10 +2422,16 @@ func (m *GroupCount) Size() (n int) {
 	if m.Count != 0 {
 		n += 1 + sovPublic(uint64(m.Count))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *ValCount) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	if m.Val != 0 {
@@ -1803,10 +2440,16 @@ func (m *ValCount) Size() (n int) {
 	if m.Count != 0 {
 		n += 1 + sovPublic(uint64(m.Count))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *ColumnAttrSet) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	if m.ID != 0 {
@@ -1822,10 +2465,16 @@ func (m *ColumnAttrSet) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPublic(uint64(l))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *Attr) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Key)
@@ -1848,10 +2497,16 @@ func (m *Attr) Size() (n int) {
 	if m.FloatValue != 0 {
 		n += 9
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *AttrMap) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	if len(m.Attrs) > 0 {
@@ -1860,10 +2515,16 @@ func (m *AttrMap) Size() (n int) {
 			n += 1 + l + sovPublic(uint64(l))
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *QueryRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Query)
@@ -1889,10 +2550,16 @@ func (m *QueryRequest) Size() (n int) {
 	if m.ExcludeColumns {
 		n += 2
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *QueryResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Err)
@@ -1911,10 +2578,16 @@ func (m *QueryResponse) Size() (n int) {
 			n += 1 + l + sovPublic(uint64(l))
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *QueryResult) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	if m.Row != nil {
@@ -1957,10 +2630,16 @@ func (m *QueryResult) Size() (n int) {
 		l = m.RowIdentifiers.Size()
 		n += 1 + l + sovPublic(uint64(l))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *ImportRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Index)
@@ -2007,10 +2686,16 @@ func (m *ImportRequest) Size() (n int) {
 			n += 1 + l + sovPublic(uint64(l))
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *ImportValueRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Index)
@@ -2044,10 +2729,19 @@ func (m *ImportValueRequest) Size() (n int) {
 			n += 1 + l + sovPublic(uint64(l))
 		}
 	}
+	if len(m.FloatValues) > 0 {
+		n += 1 + sovPublic(uint64(len(m.FloatValues)*8)) + len(m.FloatValues)*8
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *TranslateKeysRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Index)
@@ -2064,10 +2758,16 @@ func (m *TranslateKeysRequest) Size() (n int) {
 			n += 1 + l + sovPublic(uint64(l))
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *TranslateKeysResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	if len(m.IDs) > 0 {
@@ -2077,10 +2777,16 @@ func (m *TranslateKeysResponse) Size() (n int) {
 		}
 		n += 1 + sovPublic(uint64(l)) + l
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *ImportRoaringRequestView) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	l = len(m.Name)
@@ -2091,10 +2797,16 @@ func (m *ImportRoaringRequestView) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPublic(uint64(l))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
 func (m *ImportRoaringRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
 	var l int
 	_ = l
 	if m.Clear {
@@ -2106,6 +2818,9 @@ func (m *ImportRoaringRequest) Size() (n int) {
 			n += 1 + l + sovPublic(uint64(l))
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
@@ -2192,6 +2907,17 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
+				var elementCount int
+				var count int
+				for _, integer := range dAtA {
+					if integer < 128 {
+						count++
+					}
+				}
+				elementCount = count
+				if elementCount != 0 && len(m.Columns) == 0 {
+					m.Columns = make([]uint64, 0, elementCount)
+				}
 				for iNdEx < postIndex {
 					var v uint64
 					for shift := uint(0); ; shift += 7 {
@@ -2285,6 +3011,7 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -2364,6 +3091,17 @@ func (m *RowIdentifiers) Unmarshal(dAtA []byte) error {
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
+				var elementCount int
+				var count int
+				for _, integer := range dAtA {
+					if integer < 128 {
+						count++
+					}
+				}
+				elementCount = count
+				if elementCount != 0 && len(m.Rows) == 0 {
+					m.Rows = make([]uint64, 0, elementCount)
+				}
 				for iNdEx < postIndex {
 					var v uint64
 					for shift := uint(0); ; shift += 7 {
@@ -2426,6 +3164,7 @@ func (m *RowIdentifiers) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -2543,6 +3282,7 @@ func (m *Pair) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -2670,6 +3410,7 @@ func (m *FieldRow) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -2770,6 +3511,7 @@ func (m *GroupCount) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -2858,6 +3600,7 @@ func (m *ValCount) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -2987,6 +3730,7 @@ func (m *ColumnAttrSet) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -3149,7 +3893,7 @@ func (m *Attr) Unmarshal(dAtA []byte) error {
 			if (iNdEx + 8) > l {
 				return io.ErrUnexpectedEOF
 			}
-			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
 			iNdEx += 8
 			m.FloatValue = float64(math.Float64frombits(v))
 		default:
@@ -3164,6 +3908,7 @@ func (m *Attr) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -3245,6 +3990,7 @@ func (m *AttrMap) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -3353,6 +4099,17 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
+				var elementCount int
+				var count int
+				for _, integer := range dAtA {
+					if integer < 128 {
+						count++
+					}
+				}
+				elementCount = count
+				if elementCount != 0 && len(m.Shards) == 0 {
+					m.Shards = make([]uint64, 0, elementCount)
+				}
 				for iNdEx < postIndex {
 					var v uint64
 					for shift := uint(0); ; shift += 7 {
@@ -3466,6 +4223,7 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -3607,6 +4365,7 @@ func (m *QueryResponse) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -3841,6 +4600,17 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
+				var elementCount int
+				var count int
+				for _, integer := range dAtA {
+					if integer < 128 {
+						count++
+					}
+				}
+				elementCount = count
+				if elementCount != 0 && len(m.RowIDs) == 0 {
+					m.RowIDs = make([]uint64, 0, elementCount)
+				}
 				for iNdEx < postIndex {
 					var v uint64
 					for shift := uint(0); ; shift += 7 {
@@ -3938,6 +4708,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -4094,6 +4865,17 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
+				var elementCount int
+				var count int
+				for _, integer := range dAtA {
+					if integer < 128 {
+						count++
+					}
+				}
+				elementCount = count
+				if elementCount != 0 && len(m.RowIDs) == 0 {
+					m.RowIDs = make([]uint64, 0, elementCount)
+				}
 				for iNdEx < postIndex {
 					var v uint64
 					for shift := uint(0); ; shift += 7 {
@@ -4156,6 +4938,17 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
+				var elementCount int
+				var count int
+				for _, integer := range dAtA {
+					if integer < 128 {
+						count++
+					}
+				}
+				elementCount = count
+				if elementCount != 0 && len(m.ColumnIDs) == 0 {
+					m.ColumnIDs = make([]uint64, 0, elementCount)
+				}
 				for iNdEx < postIndex {
 					var v uint64
 					for shift := uint(0); ; shift += 7 {
@@ -4218,6 +5011,17 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
+				var elementCount int
+				var count int
+				for _, integer := range dAtA {
+					if integer < 128 {
+						count++
+					}
+				}
+				elementCount = count
+				if elementCount != 0 && len(m.Timestamps) == 0 {
+					m.Timestamps = make([]int64, 0, elementCount)
+				}
 				for iNdEx < postIndex {
 					var v int64
 					for shift := uint(0); ; shift += 7 {
@@ -4309,6 +5113,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -4465,6 +5270,17 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
+				var elementCount int
+				var count int
+				for _, integer := range dAtA {
+					if integer < 128 {
+						count++
+					}
+				}
+				elementCount = count
+				if elementCount != 0 && len(m.ColumnIDs) == 0 {
+					m.ColumnIDs = make([]uint64, 0, elementCount)
+				}
 				for iNdEx < postIndex {
 					var v uint64
 					for shift := uint(0); ; shift += 7 {
@@ -4527,6 +5343,17 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
+				var elementCount int
+				var count int
+				for _, integer := range dAtA {
+					if integer < 128 {
+						count++
+					}
+				}
+				elementCount = count
+				if elementCount != 0 && len(m.Values) == 0 {
+					m.Values = make([]int64, 0, elementCount)
+				}
 				for iNdEx < postIndex {
 					var v int64
 					for shift := uint(0); ; shift += 7 {
@@ -4577,6 +5404,57 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 			}
 			m.ColumnKeys = append(m.ColumnKeys, string(dAtA[iNdEx:postIndex]))
 			iNdEx = postIndex
+		case 8:
+			if wireType == 1 {
+				var v uint64
+				if (iNdEx + 8) > l {
+					return io.ErrUnexpectedEOF
+				}
+				v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+				iNdEx += 8
+				v2 := float64(math.Float64frombits(v))
+				m.FloatValues = append(m.FloatValues, v2)
+			} else if wireType == 2 {
+				var packedLen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return ErrIntOverflowPublic
+					}
+					if iNdEx >= l {
+						return io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					packedLen |= (int(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if packedLen < 0 {
+					return ErrInvalidLengthPublic
+				}
+				postIndex := iNdEx + packedLen
+				if postIndex > l {
+					return io.ErrUnexpectedEOF
+				}
+				var elementCount int
+				elementCount = packedLen / 8
+				if elementCount != 0 && len(m.FloatValues) == 0 {
+					m.FloatValues = make([]float64, 0, elementCount)
+				}
+				for iNdEx < postIndex {
+					var v uint64
+					if (iNdEx + 8) > l {
+						return io.ErrUnexpectedEOF
+					}
+					v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+					iNdEx += 8
+					v2 := float64(math.Float64frombits(v))
+					m.FloatValues = append(m.FloatValues, v2)
+				}
+			} else {
+				return fmt.Errorf("proto: wrong wireType = %d for field FloatValues", wireType)
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipPublic(dAtA[iNdEx:])
@@ -4589,6 +5467,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -4726,6 +5605,7 @@ func (m *TranslateKeysRequest) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -4805,6 +5685,17 @@ func (m *TranslateKeysResponse) Unmarshal(dAtA []byte) error {
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
+				var elementCount int
+				var count int
+				for _, integer := range dAtA {
+					if integer < 128 {
+						count++
+					}
+				}
+				elementCount = count
+				if elementCount != 0 && len(m.IDs) == 0 {
+					m.IDs = make([]uint64, 0, elementCount)
+				}
 				for iNdEx < postIndex {
 					var v uint64
 					for shift := uint(0); ; shift += 7 {
@@ -4838,6 +5729,7 @@ func (m *TranslateKeysResponse) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -4948,6 +5840,7 @@ func (m *ImportRoaringRequestView) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -5049,6 +5942,7 @@ func (m *ImportRoaringRequest) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -5163,63 +6057,64 @@ var (
 	ErrIntOverflowPublic   = fmt.Errorf("proto: integer overflow")
 )
 
-func init() { proto.RegisterFile("public.proto", fileDescriptorPublic) }
+func init() { proto.RegisterFile("public.proto", fileDescriptor_public_6f31a3d3ed4c07fc) }
 
-var fileDescriptorPublic = []byte{
-	// 880 bytes of a gzipped FileDescriptorProto
+var fileDescriptor_public_6f31a3d3ed4c07fc = []byte{
+	// 889 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcd, 0x8e, 0x1b, 0x45,
-	0x10, 0xa6, 0x3d, 0x63, 0x7b, 0x5c, 0x5e, 0x9b, 0xa8, 0xe5, 0x84, 0x11, 0x8a, 0x8c, 0x35, 0x42,
-	0x68, 0xb8, 0x6c, 0x24, 0x23, 0xa1, 0x9c, 0xf8, 0xd9, 0x78, 0x83, 0xac, 0xc0, 0x0a, 0x6a, 0x57,
-	0x46, 0x1c, 0x3b, 0x71, 0x27, 0x19, 0x69, 0x3c, 0x6d, 0x66, 0x7a, 0x70, 0xf6, 0x39, 0xb8, 0xf0,
-	0x08, 0x1c, 0x78, 0x90, 0x1c, 0x11, 0x4f, 0x00, 0xcb, 0x8b, 0xa0, 0xae, 0x9e, 0xde, 0x1e, 0x7b,
-	0x97, 0x08, 0xa1, 0xdc, 0xea, 0xab, 0xea, 0xaa, 0xa9, 0xaf, 0xfe, 0x6c, 0x38, 0xda, 0xd6, 0x4f,
-	0xf3, 0xec, 0xd9, 0xf1, 0xb6, 0x54, 0x5a, 0xf1, 0x28, 0x2b, 0xb4, 0x2c, 0x0b, 0x91, 0x27, 0x3f,
-	0x40, 0x80, 0x6a, 0xc7, 0x63, 0xe8, 0x3f, 0x52, 0x79, 0xbd, 0x29, 0xaa, 0x98, 0xcd, 0x82, 0x34,
-	0x44, 0x07, 0xf9, 0x87, 0xd0, 0xfd, 0x52, 0xeb, 0xb2, 0x8a, 0x3b, 0xb3, 0x20, 0x1d, 0xce, 0xc7,
-	0xc7, 0xce, 0xf5, 0xd8, 0xa8, 0xd1, 0x1a, 0x39, 0x87, 0xf0, 0x89, 0xbc, 0xac, 0xe2, 0x60, 0x16,
-	0xa4, 0x03, 0x24, 0x39, 0x79, 0x08, 0x63, 0x54, 0xbb, 0xe5, 0x5a, 0x16, 0x3a, 0x7b, 0x9e, 0x49,
-	0xfb, 0x0a, 0xd5, 0xce, 0x7d, 0x82, 0xe4, 0x6b, 0xcf, 0x4e, 0xcb, 0xf3, 0x33, 0x08, 0xbf, 0x15,
-	0x59, 0xc9, 0xc7, 0xd0, 0x59, 0x2e, 0x62, 0x36, 0x63, 0x69, 0x88, 0x9d, 0xe5, 0x82, 0x4f, 0xa0,
-	0xfb, 0x48, 0xd5, 0x85, 0x8e, 0x3b, 0xa4, 0xb2, 0x80, 0xdf, 0x81, 0xe0, 0x89, 0xbc, 0x8c, 0x83,
-	0x19, 0x4b, 0x07, 0x68, 0xc4, 0xe4, 0x0c, 0xa2, 0xc7, 0x99, 0xcc, 0xd7, 0x86, 0xd9, 0x04, 0xba,
-	0x24, 0x53, 0x98, 0x01, 0x5a, 0x60, 0xb4, 0x26, 0xb7, 0x85, 0x8b, 0x44, 0x80, 0xdf, 0x83, 0x1e,
-	0xaa, 0x9d, 0x0f, 0xd6, 0xa0, 0xe4, 0x6b, 0x80, 0xaf, 0x4a, 0x55, 0x6f, 0xed, 0xf7, 0x52, 0xe8,
-	0x12, 0x22, 0x1a, 0xc3, 0x39, 0xf7, 0x15, 0x71, 0x1f, 0x45, 0xfb, 0xe0, 0xf6, 0x7c, 0x93, 0x39,
-	0x44, 0x2b, 0x91, 0x5f, 0xe7, 0xbe, 0x12, 0x39, 0xe5, 0x16, 0xa0, 0x11, 0xf7, 0x7d, 0x02, 0xe7,
-	0xf3, 0x3d, 0x8c, 0x6c, 0x43, 0x4c, 0xb9, 0xcf, 0xa5, 0xbe, 0x51, 0x9a, 0xff, 0xd6, 0xa6, 0x9b,
-	0xa5, 0xfa, 0x95, 0x41, 0x68, 0x6c, 0xce, 0xc4, 0xae, 0x4d, 0xa6, 0x33, 0x17, 0x97, 0x5b, 0xd9,
-	0x24, 0x4f, 0x32, 0x9f, 0xc1, 0xf0, 0x5c, 0x97, 0x59, 0xf1, 0x62, 0x25, 0xf2, 0x5a, 0x36, 0x81,
-	0xda, 0x2a, 0xfe, 0x3e, 0x44, 0xcb, 0x42, 0x5b, 0x73, 0x48, 0x14, 0xae, 0x31, 0xbf, 0x0f, 0x83,
-	0x13, 0xa5, 0x72, 0x6b, 0xec, 0xce, 0x58, 0x1a, 0xa1, 0x57, 0xf0, 0x29, 0xc0, 0xe3, 0x5c, 0x89,
-	0xc6, 0xb7, 0x37, 0x63, 0x29, 0xc3, 0x96, 0x26, 0x79, 0x00, 0x7d, 0x93, 0xe9, 0x37, 0x62, 0xeb,
-	0xd9, 0xb2, 0x37, 0xb0, 0x4d, 0x5e, 0x33, 0x38, 0xfa, 0xae, 0x96, 0xe5, 0x25, 0xca, 0x1f, 0x6b,
-	0x59, 0x69, 0x53, 0x5b, 0xc2, 0x6e, 0x16, 0x08, 0x98, 0xae, 0x9f, 0xbf, 0x14, 0xe5, 0xda, 0xd6,
-	0x2e, 0xc4, 0x06, 0x19, 0xae, 0xbe, 0xe6, 0x15, 0x71, 0x8d, 0xb0, 0xad, 0xa2, 0x79, 0x91, 0x1b,
-	0xa5, 0x1d, 0x99, 0x06, 0xf1, 0x14, 0xde, 0x3d, 0x7d, 0xf5, 0x2c, 0xaf, 0xd7, 0x12, 0xd5, 0xce,
-	0x7a, 0xf7, 0xe8, 0xc1, 0xa1, 0x9a, 0x7f, 0x04, 0xe3, 0x46, 0xe5, 0xd6, 0xaf, 0x4f, 0x0f, 0x0f,
-	0xb4, 0xc9, 0xcf, 0x0c, 0x46, 0x0d, 0x95, 0x6a, 0xab, 0x8a, 0x4a, 0x9a, 0x7e, 0x9d, 0x96, 0xa5,
-	0xeb, 0xd7, 0x69, 0x59, 0xf2, 0x07, 0xd0, 0x47, 0x59, 0xd5, 0xb9, 0x76, 0x43, 0x70, 0xd7, 0x97,
-	0xc5, 0xf9, 0xd6, 0xb9, 0x46, 0xf7, 0x8a, 0x7f, 0x0e, 0xe3, 0xbd, 0xa1, 0xb2, 0xeb, 0x3b, 0x9c,
-	0xbf, 0xe7, 0xfd, 0xf6, 0xec, 0x78, 0xf0, 0x3c, 0xf9, 0xa3, 0x03, 0xc3, 0x56, 0x64, 0xfe, 0x01,
-	0x1d, 0x13, 0xca, 0x69, 0x38, 0x1f, 0xf9, 0x28, 0x66, 0x25, 0xe8, 0xcc, 0x1c, 0x01, 0x3b, 0x6b,
-	0xe6, 0x89, 0x9d, 0x99, 0x2e, 0x9a, 0x35, 0x77, 0x9f, 0x6d, 0x75, 0xd1, 0xa8, 0xd1, 0x1a, 0xe9,
-	0x34, 0xbd, 0x14, 0xc5, 0x0b, 0xb9, 0xa6, 0x79, 0x8a, 0xd0, 0x41, 0x7e, 0xec, 0x17, 0x89, 0x1a,
-	0xb0, 0xb7, 0x8b, 0xce, 0x82, 0x7e, 0xd9, 0xdc, 0x40, 0x9b, 0x5e, 0x8c, 0x9a, 0x81, 0xb6, 0x2b,
-	0xbf, 0x5c, 0x98, 0xc2, 0x53, 0xf3, 0x2d, 0xe2, 0x9f, 0xc2, 0xd0, 0xaf, 0x7c, 0x15, 0x47, 0x94,
-	0xe1, 0xc4, 0x87, 0xf7, 0x46, 0x6c, 0x3f, 0xe4, 0x5f, 0x1c, 0x1e, 0xbd, 0x78, 0x40, 0x99, 0xc5,
-	0x7b, 0xd5, 0x68, 0xd9, 0xf1, 0xe0, 0x7d, 0xf2, 0x17, 0x83, 0xd1, 0x72, 0xb3, 0x55, 0xa5, 0x6e,
-	0x8d, 0xed, 0xb2, 0x58, 0xcb, 0x57, 0x6e, 0x6c, 0x09, 0xf8, 0xc3, 0xd6, 0x39, 0x38, 0x6c, 0x34,
-	0xbe, 0x34, 0xae, 0x21, 0x5a, 0xd0, 0x62, 0x19, 0xee, 0xb1, 0xbc, 0x0f, 0x03, 0xdb, 0x52, 0x63,
-	0xea, 0x92, 0xc9, 0x2b, 0xcc, 0x42, 0x5e, 0x64, 0x1b, 0x59, 0x69, 0xb1, 0xd9, 0x9a, 0x09, 0x0e,
-	0xd2, 0x00, 0x5b, 0x1a, 0xd3, 0x19, 0x7b, 0x20, 0x6d, 0xf1, 0x06, 0xe8, 0xa0, 0xf1, 0xb4, 0x61,
-	0xc8, 0x18, 0x91, 0xb1, 0xa5, 0x49, 0x7e, 0x63, 0xc0, 0x2d, 0x47, 0x5a, 0xed, 0xb7, 0x47, 0xf4,
-	0xcd, 0x84, 0xee, 0x41, 0x8f, 0xbe, 0xe7, 0xc8, 0x34, 0xe8, 0x20, 0xdd, 0xfe, 0x8d, 0x74, 0x57,
-	0x30, 0xb9, 0x28, 0x45, 0x51, 0xe5, 0x42, 0x4b, 0xa3, 0xf8, 0x3f, 0xf9, 0xde, 0xf6, 0x0b, 0xf9,
-	0x31, 0xdc, 0x3d, 0x88, 0xeb, 0x97, 0xdb, 0x10, 0x08, 0x88, 0x80, 0x11, 0x93, 0x13, 0x88, 0x9b,
-	0xa1, 0x50, 0xc2, 0x1c, 0xdb, 0x26, 0x85, 0x55, 0x26, 0x77, 0x26, 0xf4, 0x99, 0xd8, 0xc8, 0x26,
-	0x0b, 0x92, 0x8d, 0x6e, 0x21, 0xb4, 0xa0, 0x1c, 0x8e, 0x90, 0xe4, 0xe4, 0x39, 0x4c, 0x6e, 0x8b,
-	0x41, 0x3f, 0x39, 0xb9, 0x14, 0xf6, 0x98, 0x44, 0x68, 0x01, 0x7f, 0x08, 0xdd, 0x9f, 0x32, 0xb9,
-	0x73, 0xc7, 0x24, 0xf1, 0x03, 0xfc, 0x6f, 0x89, 0xa0, 0x75, 0x38, 0xb9, 0xf3, 0xfa, 0x6a, 0xca,
-	0x7e, 0xbf, 0x9a, 0xb2, 0x3f, 0xaf, 0xa6, 0xec, 0x97, 0xbf, 0xa7, 0xef, 0x3c, 0xed, 0xd1, 0xdf,
-	0x8e, 0x4f, 0xfe, 0x09, 0x00, 0x00, 0xff, 0xff, 0x9f, 0x87, 0xba, 0x9b, 0x86, 0x08, 0x00, 0x00,
+	0x10, 0xa6, 0x3d, 0xfe, 0x19, 0x97, 0xd7, 0x26, 0x6a, 0x39, 0x61, 0x84, 0x22, 0x63, 0x8d, 0x10,
+	0x1a, 0x2e, 0x1b, 0xc9, 0x48, 0x28, 0x27, 0x7e, 0x36, 0xde, 0x20, 0x2b, 0xb0, 0x82, 0xda, 0x95,
+	0x11, 0xc7, 0x4e, 0xdc, 0x49, 0x46, 0x1a, 0x4f, 0x9b, 0x99, 0x1e, 0x9c, 0x7d, 0x0e, 0x2e, 0x3c,
+	0x02, 0x8f, 0x92, 0x13, 0x42, 0x3c, 0x01, 0x2c, 0x2f, 0x82, 0xba, 0x7a, 0x7a, 0x7b, 0x3c, 0x59,
+	0x56, 0x08, 0xe5, 0x56, 0x5f, 0x55, 0x57, 0x4d, 0x7d, 0xf5, 0x67, 0xc3, 0xd1, 0xae, 0x7a, 0x9a,
+	0xa5, 0xcf, 0x8e, 0x77, 0x85, 0xd2, 0x8a, 0x87, 0x69, 0xae, 0x65, 0x91, 0x8b, 0x2c, 0xfe, 0x01,
+	0x02, 0x54, 0x7b, 0x1e, 0xc1, 0xe0, 0x91, 0xca, 0xaa, 0x6d, 0x5e, 0x46, 0x6c, 0x1e, 0x24, 0x5d,
+	0x74, 0x90, 0x7f, 0x08, 0xbd, 0x2f, 0xb5, 0x2e, 0xca, 0xa8, 0x33, 0x0f, 0x92, 0xd1, 0x62, 0x72,
+	0xec, 0x5c, 0x8f, 0x8d, 0x1a, 0xad, 0x91, 0x73, 0xe8, 0x3e, 0x91, 0x97, 0x65, 0x14, 0xcc, 0x83,
+	0x64, 0x88, 0x24, 0xc7, 0x0f, 0x61, 0x82, 0x6a, 0xbf, 0xda, 0xc8, 0x5c, 0xa7, 0xcf, 0x53, 0x69,
+	0x5f, 0xa1, 0xda, 0xbb, 0x4f, 0x90, 0x7c, 0xed, 0xd9, 0x69, 0x78, 0x7e, 0x06, 0xdd, 0x6f, 0x45,
+	0x5a, 0xf0, 0x09, 0x74, 0x56, 0xcb, 0x88, 0xcd, 0x59, 0xd2, 0xc5, 0xce, 0x6a, 0xc9, 0xa7, 0xd0,
+	0x7b, 0xa4, 0xaa, 0x5c, 0x47, 0x1d, 0x52, 0x59, 0xc0, 0xef, 0x40, 0xf0, 0x44, 0x5e, 0x46, 0xc1,
+	0x9c, 0x25, 0x43, 0x34, 0x62, 0x7c, 0x06, 0xe1, 0xe3, 0x54, 0x66, 0x1b, 0xc3, 0x6c, 0x0a, 0x3d,
+	0x92, 0x29, 0xcc, 0x10, 0x2d, 0x30, 0x5a, 0x93, 0xdb, 0xd2, 0x45, 0x22, 0xc0, 0xef, 0x41, 0x1f,
+	0xd5, 0xde, 0x07, 0xab, 0x51, 0xfc, 0x35, 0xc0, 0x57, 0x85, 0xaa, 0x76, 0xf6, 0x7b, 0x09, 0xf4,
+	0x08, 0x11, 0x8d, 0xd1, 0x82, 0xfb, 0x8a, 0xb8, 0x8f, 0xa2, 0x7d, 0x70, 0x73, 0xbe, 0xf1, 0x02,
+	0xc2, 0xb5, 0xc8, 0xae, 0x73, 0x5f, 0x8b, 0x8c, 0x72, 0x0b, 0xd0, 0x88, 0x87, 0x3e, 0x81, 0xf3,
+	0xf9, 0x1e, 0xc6, 0xb6, 0x21, 0xa6, 0xdc, 0xe7, 0x52, 0xbf, 0x51, 0x9a, 0xff, 0xd6, 0xa6, 0x37,
+	0x4b, 0xf5, 0x2b, 0x83, 0xae, 0xb1, 0x39, 0x13, 0xbb, 0x36, 0x99, 0xce, 0x5c, 0x5c, 0xee, 0x64,
+	0x9d, 0x3c, 0xc9, 0x7c, 0x0e, 0xa3, 0x73, 0x5d, 0xa4, 0xf9, 0x8b, 0xb5, 0xc8, 0x2a, 0x59, 0x07,
+	0x6a, 0xaa, 0xf8, 0xfb, 0x10, 0xae, 0x72, 0x6d, 0xcd, 0x5d, 0xa2, 0x70, 0x8d, 0xf9, 0x7d, 0x18,
+	0x9e, 0x28, 0x95, 0x59, 0x63, 0x6f, 0xce, 0x92, 0x10, 0xbd, 0x82, 0xcf, 0x00, 0x1e, 0x67, 0x4a,
+	0xd4, 0xbe, 0xfd, 0x39, 0x4b, 0x18, 0x36, 0x34, 0xf1, 0x03, 0x18, 0x98, 0x4c, 0xbf, 0x11, 0x3b,
+	0xcf, 0x96, 0xdd, 0xc2, 0x36, 0x7e, 0xcd, 0xe0, 0xe8, 0xbb, 0x4a, 0x16, 0x97, 0x28, 0x7f, 0xac,
+	0x64, 0xa9, 0x4d, 0x6d, 0x09, 0xbb, 0x59, 0x20, 0x60, 0xba, 0x7e, 0xfe, 0x52, 0x14, 0x1b, 0x5b,
+	0xbb, 0x2e, 0xd6, 0xc8, 0x70, 0xf5, 0x35, 0x2f, 0x89, 0x6b, 0x88, 0x4d, 0x15, 0xcd, 0x8b, 0xdc,
+	0x2a, 0xed, 0xc8, 0xd4, 0x88, 0x27, 0xf0, 0xee, 0xe9, 0xab, 0x67, 0x59, 0xb5, 0x91, 0xa8, 0xf6,
+	0xd6, 0xbb, 0x4f, 0x0f, 0xda, 0x6a, 0xfe, 0x11, 0x4c, 0x6a, 0x95, 0x5b, 0xbf, 0x01, 0x3d, 0x6c,
+	0x69, 0xe3, 0x9f, 0x19, 0x8c, 0x6b, 0x2a, 0xe5, 0x4e, 0xe5, 0xa5, 0x34, 0xfd, 0x3a, 0x2d, 0x0a,
+	0xd7, 0xaf, 0xd3, 0xa2, 0xe0, 0x0f, 0x60, 0x80, 0xb2, 0xac, 0x32, 0xed, 0x86, 0xe0, 0xae, 0x2f,
+	0x8b, 0xf3, 0xad, 0x32, 0x8d, 0xee, 0x15, 0xff, 0x1c, 0x26, 0x07, 0x43, 0x65, 0xd7, 0x77, 0xb4,
+	0x78, 0xcf, 0xfb, 0x1d, 0xd8, 0xb1, 0xf5, 0x3c, 0xfe, 0xa3, 0x03, 0xa3, 0x46, 0x64, 0xfe, 0x01,
+	0x1d, 0x13, 0xca, 0x69, 0xb4, 0x18, 0xfb, 0x28, 0x66, 0x25, 0xe8, 0xcc, 0x1c, 0x01, 0x3b, 0xab,
+	0xe7, 0x89, 0x9d, 0x99, 0x2e, 0x9a, 0x35, 0x77, 0x9f, 0x6d, 0x74, 0xd1, 0xa8, 0xd1, 0x1a, 0xe9,
+	0x34, 0xbd, 0x14, 0xf9, 0x0b, 0xb9, 0xa1, 0x79, 0x0a, 0xd1, 0x41, 0x7e, 0xec, 0x17, 0x89, 0x1a,
+	0x70, 0xb0, 0x8b, 0xce, 0x82, 0x7e, 0xd9, 0xdc, 0x40, 0x9b, 0x5e, 0x8c, 0xeb, 0x81, 0xb6, 0x2b,
+	0xbf, 0x5a, 0x9a, 0xc2, 0x53, 0xf3, 0x2d, 0xe2, 0x9f, 0xc2, 0xc8, 0xaf, 0x7c, 0x19, 0x85, 0x94,
+	0xe1, 0xd4, 0x87, 0xf7, 0x46, 0x6c, 0x3e, 0xe4, 0x5f, 0xb4, 0x8f, 0x5e, 0x34, 0xa4, 0xcc, 0xa2,
+	0x83, 0x6a, 0x34, 0xec, 0xd8, 0x7a, 0x1f, 0xff, 0xc5, 0x60, 0xbc, 0xda, 0xee, 0x54, 0xa1, 0x1b,
+	0x63, 0xbb, 0xca, 0x37, 0xf2, 0x95, 0x1b, 0x5b, 0x02, 0xfe, 0xb0, 0x75, 0x5a, 0x87, 0x8d, 0xc6,
+	0x97, 0xc6, 0xb5, 0x8b, 0x16, 0x34, 0x58, 0x76, 0x0f, 0x58, 0xde, 0x87, 0xa1, 0x6d, 0xa9, 0x31,
+	0xf5, 0xc8, 0xe4, 0x15, 0x66, 0x21, 0x2f, 0xd2, 0xad, 0x2c, 0xb5, 0xd8, 0xee, 0xcc, 0x04, 0x07,
+	0x49, 0x80, 0x0d, 0x8d, 0xe9, 0x8c, 0x3d, 0x90, 0xb6, 0x78, 0x43, 0x74, 0xd0, 0x78, 0xda, 0x30,
+	0x64, 0x0c, 0xc9, 0xd8, 0xd0, 0xc4, 0xbf, 0x31, 0xe0, 0x96, 0x23, 0xad, 0xf6, 0xdb, 0x23, 0x7a,
+	0x3b, 0xa1, 0x7b, 0xd0, 0xa7, 0xef, 0x39, 0x32, 0x35, 0x6a, 0xa5, 0x3b, 0x68, 0xa7, 0x6b, 0x2e,
+	0x81, 0xbf, 0x43, 0x96, 0x0f, 0xc3, 0xa6, 0x2a, 0x5e, 0xc3, 0xf4, 0xa2, 0x10, 0x79, 0x99, 0x09,
+	0x2d, 0x8d, 0xcb, 0xff, 0x61, 0x74, 0xd3, 0x6f, 0xe8, 0xc7, 0x70, 0xb7, 0x15, 0xd7, 0xaf, 0xbf,
+	0xa1, 0x18, 0x10, 0x45, 0x23, 0xc6, 0x27, 0x10, 0xd5, 0x63, 0xa3, 0x84, 0x39, 0xc7, 0x75, 0x0a,
+	0xeb, 0x54, 0xee, 0x4d, 0xe8, 0x33, 0xb1, 0x95, 0x75, 0x16, 0x24, 0x1b, 0xdd, 0x52, 0x68, 0x41,
+	0x39, 0x1c, 0x21, 0xc9, 0xf1, 0x73, 0x98, 0xde, 0x14, 0x83, 0x7e, 0x94, 0x32, 0x29, 0xec, 0xb9,
+	0x09, 0xd1, 0x02, 0xfe, 0x10, 0x7a, 0x3f, 0xa5, 0x72, 0xef, 0xce, 0x4d, 0xec, 0x47, 0xfc, 0xdf,
+	0x12, 0x41, 0xeb, 0x70, 0x72, 0xe7, 0xf5, 0xd5, 0x8c, 0xfd, 0x7e, 0x35, 0x63, 0x7f, 0x5e, 0xcd,
+	0xd8, 0x2f, 0x7f, 0xcf, 0xde, 0x79, 0xda, 0xa7, 0x3f, 0x26, 0x9f, 0xfc, 0x13, 0x00, 0x00, 0xff,
+	0xff, 0x63, 0x73, 0xa7, 0x50, 0xa8, 0x08, 0x00, 0x00,
 }
diff --git a/internal/public.proto b/internal/public.proto
index 592874b95..5c48cf016 100644
--- a/internal/public.proto
+++ b/internal/public.proto
@@ -99,6 +99,7 @@ message ImportValueRequest {
 	repeated uint64 ColumnIDs = 5;
 	repeated string ColumnKeys = 7;
 	repeated int64 Values = 6;
+	repeated double FloatValues = 8;
 }
 
 message TranslateKeysRequest {
diff --git a/view.go b/view.go
index cd976240a..89484fa3f 100644
--- a/view.go
+++ b/view.go
@@ -210,7 +210,7 @@ fragLoop:
 // flags returns a set of flags for the underlying fragments.
 func (v *view) flags() byte {
 	var flag byte
-	if v.fieldType == FieldTypeInt {
+	if v.fieldType == FieldTypeInt || v.fieldType == FieldTypeDecimal {
 		flag |= roaringFlagBSIv2
 	}
 	return flag