diff --git a/api.go b/api.go
index 381387dbb..2a74f3b11 100644
--- a/api.go
+++ b/api.go
@@ -544,7 +544,7 @@ func (api *API) ExportCSV(ctx context.Context, indexName string, fieldName strin
 		var colStr string
 		var err error
 
-		if field.keys() {
+		if field.Keys() {
 			if rowStr, err = field.TranslateStore().TranslateID(rowID); err != nil {
 				return errors.Wrap(err, "translating row")
 			}
@@ -961,7 +961,7 @@ func (api *API) Import(ctx context.Context, req *ImportRequest, opts ...ImportOp
 	// check to see if keys need translation.
 	if !options.IgnoreKeyCheck {
 		// Translate row keys.
-		if field.keys() {
+		if field.Keys() {
 			if len(req.RowIDs) != 0 {
 				return errors.New("row ids cannot be used because field uses string keys")
 			}
@@ -982,7 +982,7 @@ func (api *API) Import(ctx context.Context, req *ImportRequest, opts ...ImportOp
 
 		// For translated data, map the columnIDs to shards. If
 		// this node does not own the shard, forward to the node that does.
-		if index.Keys() || field.keys() {
+		if index.Keys() || field.Keys() {
 			m := make(map[uint64][]Bit)
 
 			for i, colID := range req.ColumnIDs {
@@ -1085,6 +1085,22 @@ func (api *API) ImportValue(ctx context.Context, req *ImportValueRequest, opts .
 			}
 			req.Shard = math.MaxUint64
 		}
+
+		// Translate values when the field uses keys (for example, when
+		// the field has a ForeignIndex with keys).
+		if field.Keys() {
+			uints, err := field.translateStore.TranslateKeys(req.StringValues)
+			if err != nil {
+				return errors.Wrap(err, "translating string values")
+			}
+			// Because the BSI field supports negative value, we have to
+			// convert the slice of uint64 keys to a slice of int64.
+			ints := make([]int64, len(uints))
+			for i := range uints {
+				ints[i] = int64(uints[i])
+			}
+			req.Values = ints
+		}
 	}
 
 	if !options.Presorted {
diff --git a/api/client/grpc.go b/api/client/grpc.go
index fa9f33b68..55c98f496 100644
--- a/api/client/grpc.go
+++ b/api/client/grpc.go
@@ -17,53 +17,115 @@ package client
 import (
 	"context"
 	"crypto/tls"
+	"log"
+	"sync"
 
 	pb "github.com/pilosa/pilosa/v2/proto"
 	"github.com/pkg/errors"
 	"google.golang.org/grpc"
+	"google.golang.org/grpc/connectivity"
 	"google.golang.org/grpc/credentials"
 )
 
 // GRPCClient is a client for working with the gRPC server.
 type GRPCClient struct {
+	dialTarget string
+	tlsConfig  *tls.Config
+
+	mu   sync.RWMutex
 	conn *grpc.ClientConn
 }
 
 // NewGRPCClient returns a new instance of GRPCClient.
 func NewGRPCClient(dialTarget string, tlsConfig *tls.Config) (*GRPCClient, error) {
+	c := &GRPCClient{
+		dialTarget: dialTarget,
+		tlsConfig:  tlsConfig,
+	}
+	// resetConn sets GRPCClient.conn when it doesn't
+	// exist yet.
+	if err := c.resetConn(); err != nil {
+		return nil, errors.Wrap(err, "setting connection")
+	}
+
+	return c, nil
+}
+
+// resetConn resets the gRPC client connection. This method
+// can also be used to initially set the client connection
+// because it only tries to first close the connection if
+// the connection already exists.
+func (c *GRPCClient) resetConn() error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	// If an existing connection exists, close it first.
+	if c.conn != nil {
+		if err := c.conn.Close(); err != nil {
+			return errors.Wrap(err, "closing existing connection")
+		}
+	}
+
 	var opts []grpc.DialOption
-	if tlsConfig != nil {
-		creds := credentials.NewTLS(tlsConfig)
+	if c.tlsConfig != nil {
+		creds := credentials.NewTLS(c.tlsConfig)
 		opts = append(opts, grpc.WithTransportCredentials(creds))
 	} else {
 		opts = append(opts, grpc.WithInsecure())
 	}
 
-	gconn, err := grpc.Dial(dialTarget, opts...)
-	if err != nil {
-		return nil, errors.Wrap(err, "creating new grpc client")
+	var err error
+	if c.conn, err = grpc.Dial(c.dialTarget, opts...); err != nil {
+		return errors.Wrap(err, "creating new grpc client")
 	}
 
-	return &GRPCClient{
-		conn: gconn,
-	}, nil
+	return nil
 }
 
 // Close closes any connections the client has opened.
 func (c *GRPCClient) Close() error {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
 	if c.conn != nil {
 		return c.conn.Close()
 	}
 	return nil
 }
 
+// Conn returns the gRPC client connection. If the connection
+// has gone into state `TransientFailure`, this method tries
+// to reset the connection and return that new connection.
+func (c *GRPCClient) Conn() *grpc.ClientConn {
+	c.mu.RLock()
+	if c.conn == nil {
+		c.mu.RUnlock()
+		return nil
+	} else if c.conn.GetState() != connectivity.TransientFailure {
+		defer c.mu.RUnlock()
+		return c.conn
+	}
+	c.mu.RUnlock()
+
+	if err := c.resetConn(); err != nil {
+		// TODO: log this error with logger
+		log.Printf("error resetting connection: %s", err)
+	}
+
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	return c.conn
+}
+
 // Query returns a stream of RowResponse for the given index and PQL string.
 func (c *GRPCClient) Query(ctx context.Context, index string, pql string) (pb.StreamClient, error) {
-	if c.conn == nil {
+	conn := c.Conn()
+
+	if conn == nil {
 		return nil, errors.New("client has not established a grpc connection")
 	}
 
-	grpcClient := pb.NewPilosaClient(c.conn)
+	grpcClient := pb.NewPilosaClient(conn)
 
 	stream, err := grpcClient.QueryPQL(ctx, &pb.QueryPQLRequest{
 		Index: index,
@@ -81,7 +143,9 @@ func (c *GRPCClient) Query(ctx context.Context, index string, pql string) (pb.St
 // Inspect returns a stream of RowResponse for the given index, columns, and filters.
 // It is intended to mimic something like "select [fields] from table where recordID IN (...)".
 func (c *GRPCClient) Inspect(ctx context.Context, index string, columnIDs []uint64, columnKeys []string, fieldFilters []string, limit, offset uint64) (pb.StreamClient, error) {
-	if c.conn == nil {
+	conn := c.Conn()
+
+	if conn == nil {
 		return nil, errors.New("client has not established a grpc connection")
 	}
 
@@ -97,7 +161,7 @@ func (c *GRPCClient) Inspect(ctx context.Context, index string, columnIDs []uint
 		idsOrKeys.Type = &pb.IdsOrKeys_Ids{Ids: &pb.Uint64Array{Vals: columnIDs}}
 	}
 
-	grpcClient := pb.NewPilosaClient(c.conn)
+	grpcClient := pb.NewPilosaClient(conn)
 
 	stream, err := grpcClient.Inspect(ctx, &pb.InspectRequest{
 		Index:        index,
diff --git a/api_test.go b/api_test.go
index aabbaa700..955f01f81 100644
--- a/api_test.go
+++ b/api_test.go
@@ -481,6 +481,61 @@ func TestAPI_ImportValue(t *testing.T) {
 		}
 
 	})
+
+	t.Run("ValStringField", func(t *testing.T) {
+		ctx := context.Background()
+		index := "valstr"
+		field := "fstr"
+
+		fgnIndex := "fgnvalstr"
+
+		_, err := m0.API.CreateIndex(ctx, index, pilosa.IndexOptions{})
+		if err != nil {
+			t.Fatalf("creating index: %v", err)
+		}
+
+		_, err = m0.API.CreateIndex(ctx, fgnIndex, pilosa.IndexOptions{Keys: true})
+		if err != nil {
+			t.Fatalf("creating foreign index: %v", err)
+		}
+		_, err = m0.API.CreateField(ctx, index, field,
+			pilosa.OptFieldTypeInt(0, math.MaxInt64),
+			pilosa.OptFieldForeignIndex(fgnIndex),
+		)
+		if err != nil {
+			t.Fatalf("creating field: %v", err)
+		}
+
+		// Generate some keyed records.
+		values := []string{}
+		colIDs := []uint64{}
+		for i := 0; i < 10; i++ {
+			value := fmt.Sprintf("strval-%d", (i)*100+10)
+			values = append(values, value)
+			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,
+			StringValues: values,
+		}
+		if err := m0.API.ImportValue(ctx, req); err != nil {
+			t.Fatal(err)
+		}
+
+		pql := fmt.Sprintf(`Row(%s=="strval-110")`, 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, []uint64{1}) {
+			t.Fatalf("unexpected columns: %+v", ids)
+		}
+	})
 }
 
 // offsetModHasher represents a simple, mod-based hashing offset by 1.
diff --git a/ctl/import.go b/ctl/import.go
index 208eede07..32a49be49 100644
--- a/ctl/import.go
+++ b/ctl/import.go
@@ -108,6 +108,8 @@ func (cmd *ImportCommand) Run(ctx context.Context) error {
 				cmd.FieldOptions.Type = pilosa.FieldTypeInt
 			} else {
 				cmd.FieldOptions.Type = pilosa.FieldTypeSet
+				cmd.FieldOptions.CacheType = pilosa.CacheTypeRanked
+				cmd.FieldOptions.CacheSize = pilosa.DefaultCacheSize
 			}
 		}
 		err := cmd.ensureSchema(ctx)
diff --git a/docs/getting-started.md b/docs/getting-started.md
index a236d2156..982bf1ca1 100644
--- a/docs/getting-started.md
+++ b/docs/getting-started.md
@@ -100,7 +100,7 @@ curl localhost:10101/index/repository -X POST
 ``` response
 {"success":true}
 ```
-The index name must be 64 characters or fewer, start with a letter, and consist only of lowercase alphanumeric characters or `_-`. The same goes for field names.
+The index name must be 230 characters or fewer, start with a letter, and consist only of lowercase alphanumeric characters or `_-`. The same goes for field names.
 
 Let's create the `stargazer` field which has user IDs of stargazers as its rows:
 ``` request
@@ -325,7 +325,7 @@ Next, let's create the `repository` index:
 	repository := schema.Index("repository")
 ```
 
-The index name must be 64 characters or fewer, start with a letter, and consist only of lowercase alphanumeric characters or `_-`. The same goes for field names.
+The index name must be 230 characters or fewer, start with a letter, and consist only of lowercase alphanumeric characters or `_-`. The same goes for field names.
 
 Let's create the `stargazer` field which has user IDs of stargazers as its rows:
 ```
@@ -615,7 +615,7 @@ Next, let's create the `repository` index:
 ```
 	Index repository = schema.index("repository");
 ```
-The index name must be 64 characters or fewer, start with a letter, and consist only of lowercase alphanumeric characters or `_-`. The same goes for field names.
+The index name must be 230 characters or fewer, start with a letter, and consist only of lowercase alphanumeric characters or `_-`. The same goes for field names.
 
 Let's create the `stargazer` field which has user IDs of stargazers as its rows:
 ```
@@ -818,7 +818,7 @@ Next, let's create the `repository` index:
 ```
 repository = schema.index("repository")
 ```
-The index name must be 64 characters or fewer, start with a letter, and consist only of lowercase alphanumeric characters or `_-`. The same goes for field names.
+The index name must be 230 characters or fewer, start with a letter, and consist only of lowercase alphanumeric characters or `_-`. The same goes for field names.
 
 Let's create the `stargazer` field which has user IDs of stargazers as its rows:
 ```
diff --git a/docs/query-language.md b/docs/query-language.md
index 4413d95d7..527cad445 100644
--- a/docs/query-language.md
+++ b/docs/query-language.md
@@ -43,7 +43,7 @@ curl localhost:10101/index/repository/query \
 
 #### Arguments and Types
 
-* `field` The field specifies on which Pilosa [field](../glossary/#field) the query will operate. Valid field names are lower case strings; they start with a lowercase letter, and contain only alphanumeric characters and `_-`. They must be 64 characters or less in length.
+* `field` The field specifies on which Pilosa [field](../glossary/#field) the query will operate. Valid field names are lower case strings; they start with a lowercase letter, and contain only alphanumeric characters and `_-`. They must be 230 characters or less in length.
 * `TIMESTAMP` This is a timestamp in the following format `YYYY-MM-DDTHH:MM` (e.g. 2006-01-02T15:04).
 * `UINT` An unsigned integer (e.g. 42839).
 * `BOOL` A boolean value, `true` or `false`.
diff --git a/encoding/proto/proto.go b/encoding/proto/proto.go
index 74313e4cf..be6ae3511 100644
--- a/encoding/proto/proto.go
+++ b/encoding/proto/proto.go
@@ -399,13 +399,14 @@ 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,
-		FloatValues: m.FloatValues,
+		Index:        m.Index,
+		Field:        m.Field,
+		Shard:        m.Shard,
+		ColumnIDs:    m.ColumnIDs,
+		ColumnKeys:   m.ColumnKeys,
+		Values:       m.Values,
+		FloatValues:  m.FloatValues,
+		StringValues: m.StringValues,
 	}
 }
 
@@ -587,16 +588,17 @@ func encodeFieldOptions(o *pilosa.FieldOptions) *internal.FieldOptions {
 		return nil
 	}
 	return &internal.FieldOptions{
-		Type:        o.Type,
-		CacheType:   o.CacheType,
-		CacheSize:   o.CacheSize,
-		Min:         o.Min,
-		Max:         o.Max,
-		Base:        o.Base,
-		Scale:       o.Scale,
-		BitDepth:    uint64(o.BitDepth),
-		TimeQuantum: string(o.TimeQuantum),
-		Keys:        o.Keys,
+		Type:         o.Type,
+		CacheType:    o.CacheType,
+		CacheSize:    o.CacheSize,
+		Min:          o.Min,
+		Max:          o.Max,
+		Base:         o.Base,
+		Scale:        o.Scale,
+		BitDepth:     uint64(o.BitDepth),
+		TimeQuantum:  string(o.TimeQuantum),
+		Keys:         o.Keys,
+		ForeignIndex: o.ForeignIndex,
 	}
 }
 
@@ -882,6 +884,7 @@ func decodeFieldOptions(options *internal.FieldOptions, m *pilosa.FieldOptions)
 	m.BitDepth = uint(options.BitDepth)
 	m.TimeQuantum = pilosa.TimeQuantum(options.TimeQuantum)
 	m.Keys = options.Keys
+	m.ForeignIndex = options.ForeignIndex
 }
 
 func decodeNodes(a []*internal.Node, m []*pilosa.Node) {
@@ -1059,6 +1062,7 @@ func decodeImportValueRequest(pb *internal.ImportValueRequest, m *pilosa.ImportV
 	m.ColumnKeys = pb.ColumnKeys
 	m.Values = pb.Values
 	m.FloatValues = pb.FloatValues
+	m.StringValues = pb.StringValues
 }
 
 func decodeImportRoaringRequest(pb *internal.ImportRoaringRequest, m *pilosa.ImportRoaringRequest) {
diff --git a/executor.go b/executor.go
index 12f0897fd..a36ea9d0e 100644
--- a/executor.go
+++ b/executor.go
@@ -3688,7 +3688,7 @@ func (e *executor) translateCall(indexName string, idx *Index, isDefaultIndex bo
 					}
 					c.Args[rowKey] = rowID
 				}
-			} else if field.keys() {
+			} else if field.Keys() {
 				if c.Args[rowKey] != nil && !isString(c.Args[rowKey]) {
 					// allow passing row id directly (this can come in handy, but make sure it is a valid row id)
 					if !isValidID(c.Args[rowKey]) {
@@ -3762,7 +3762,7 @@ func (e *executor) translateGroupByCall(index string, idx *Index, isDefaultIndex
 
 	for i, field := range fields {
 		prev := previous[i]
-		if field.keys() {
+		if field.Keys() {
 			prevStr, ok := prev.(string)
 			if !ok {
 				return errors.New("prev value must be a string when field 'keys' option enabled")
@@ -3838,13 +3838,47 @@ func (e *executor) translateResult(index string, idx *Index, call *pql.Call, res
 			return other, nil
 		}
 
+	// TODO: instead of supporting SignedRow here, we may be able to
+	// make the return type for an int field with a ForeignIndex be
+	// a *Row instead (because it should always be positive).
+	case SignedRow:
+		var store TranslateStore
+
+		if fieldName := callArgString(call, "field"); fieldName != "" {
+			field := idx.Field(fieldName)
+			if field != nil && field.Keys() {
+				store = field.TranslateStore()
+			}
+		}
+
+		// In the case where a field/foreignIndex doesn't exist,
+		// fall back to using the index translateStore.
+		if store == nil && idx.Keys() {
+			store = idx.translateStore
+		}
+
+		if store != nil {
+			rslt := result.Pos
+			other := &Row{Attrs: rslt.Attrs}
+			for _, segment := range rslt.Segments() {
+				for _, col := range segment.Columns() {
+					key, err := store.TranslateID(col)
+					if err != nil {
+						return nil, err
+					}
+					other.Keys = append(other.Keys, key)
+				}
+			}
+			return SignedRow{Pos: other}, nil
+		}
+
 	case PairField:
 		if fieldName := callArgString(call, "field"); fieldName != "" {
 			field := idx.Field(fieldName)
 			if field == nil {
 				return nil, fmt.Errorf("field %q not found", fieldName)
 			}
-			if field.keys() {
+			if field.Keys() {
 				key, err := field.TranslateStore().TranslateID(result.Pair.ID)
 				if err != nil {
 					return nil, err
@@ -3866,7 +3900,7 @@ func (e *executor) translateResult(index string, idx *Index, call *pql.Call, res
 			if field == nil {
 				return nil, fmt.Errorf("field %q not found", fieldName)
 			}
-			if field.keys() {
+			if field.Keys() {
 				other := make([]Pair, len(result.Pairs))
 				for i := range result.Pairs {
 					key, err := field.TranslateStore().TranslateID(result.Pairs[i].ID)
@@ -3895,7 +3929,7 @@ func (e *executor) translateResult(index string, idx *Index, call *pql.Call, res
 				if field == nil {
 					return nil, ErrFieldNotFound
 				}
-				if field.keys() {
+				if field.Keys() {
 					key, err := field.TranslateStore().TranslateID(g.RowID)
 					if err != nil {
 						return nil, errors.Wrap(err, "translating row ID in Group")
@@ -3924,7 +3958,7 @@ func (e *executor) translateResult(index string, idx *Index, call *pql.Call, res
 
 		if field := idx.Field(fieldName); field == nil {
 			return nil, ErrFieldNotFound
-		} else if field.keys() {
+		} else if field.Keys() {
 			other.Keys = make([]string, len(result))
 			for i, id := range result {
 				key, err := field.TranslateStore().TranslateID(id)
@@ -4137,6 +4171,11 @@ func isString(v interface{}) bool {
 	return ok
 }
 
+func isCondition(v interface{}) bool {
+	_, ok := v.(*pql.Condition)
+	return ok
+}
+
 // isValidID returns whether v can be interpreted as a valid row or
 // column ID. In short, is v a non-negative integer? I think the int64
 // and default cases are the only ones actually used since the PQL
diff --git a/executor_test.go b/executor_test.go
index 46ea95e8c..e3002a70c 100644
--- a/executor_test.go
+++ b/executor_test.go
@@ -3854,6 +3854,70 @@ func TestExecutor_Execute_Rows_Keys(t *testing.T) {
 
 }
 
+func TestExecutor_ForeignIndex(t *testing.T) {
+	c := test.MustRunCluster(t, 1)
+	defer c.Close()
+
+	c.CreateField(t, "parent", pilosa.IndexOptions{Keys: true}, "general")
+	c.CreateField(t, "child", pilosa.IndexOptions{}, "parent_id",
+		pilosa.OptFieldTypeInt(0, math.MaxInt64),
+		pilosa.OptFieldForeignIndex("parent"),
+	)
+	c.CreateField(t, "child", pilosa.IndexOptions{}, "color",
+		pilosa.OptFieldKeys(),
+	)
+
+	// Populate parent data.
+	c.Query(t, "parent", `
+			Set("one", general=1)
+			Set("two", general=1)
+			Set("three", general=1)
+
+			Set("twenty-one", general=2)
+			Set("twenty-two", general=2)
+			Set("twenty-three", general=2)
+
+			Set("one", general=3)
+			Set("twenty-one", general=3)
+		`)
+
+	// Populate child data.
+	c.Query(t, "child", `
+			Set(1, parent_id="one")
+			Set(2, parent_id="two")
+			Set(3, parent_id="one")
+			Set(4, parent_id="twenty-one")
+		`)
+
+	// Populate color data.
+	c.Query(t, "child", `
+			Set(1, color="red")
+			Set(2, color="blue")
+			Set(3, color="blue")
+			Set(4, color="red")
+		`)
+
+	distinct := c.Query(t, "child", `Distinct(index="child", field="parent_id")`).Results[0].(pilosa.SignedRow)
+	if !reflect.DeepEqual(distinct.Pos.Keys, []string{"one", "two", "twenty-one"}) {
+		t.Fatalf("unexpected keys: %v", distinct.Pos.Keys)
+	}
+
+	eq := c.Query(t, "child", `Row(parent_id=="one")`).Results[0].(*pilosa.Row)
+	if !reflect.DeepEqual(eq.Columns(), []uint64{1, 3}) {
+		t.Fatalf("unexpected columns: %v", eq.Columns())
+	}
+
+	neq := c.Query(t, "child", `Row(parent_id!="one")`).Results[0].(*pilosa.Row)
+	if !reflect.DeepEqual(neq.Columns(), []uint64{2, 4}) {
+		t.Fatalf("unexpected columns: %v", neq.Columns())
+	}
+
+	join := c.Query(t, "parent", `Intersect(Row(general=3), Distinct(Row(color="blue"), index="child", field="parent_id"))`).Results[0].(*pilosa.Row)
+	if !reflect.DeepEqual(join.Keys, []string{"one"}) {
+		t.Fatalf("unexpected keys: %v", join.Keys)
+	}
+}
+
 func TestExecutor_Execute_GroupBy(t *testing.T) {
 	groupByTest := func(t *testing.T, clusterSize int) {
 		c := test.MustRunCluster(t, 1)
diff --git a/field.go b/field.go
index 75691be52..0c41534d0 100644
--- a/field.go
+++ b/field.go
@@ -81,6 +81,15 @@ type Field struct {
 	// Field options.
 	options FieldOptions
 
+	// finalOptions is used with a final call to applyOptions.
+	// The initial call to applyOptions is made with options
+	// loaded from the meta file on disk (in the case when
+	// a field is being re-opened). If the field creator calls
+	// setOptions before calling Open(), then those options
+	// will be held in finalOptions, and applied instead of
+	// those from the meta file.
+	finalOptions *FieldOptions
+
 	bsiGroups []*bsiGroup
 
 	// Shards with data on any node in the cluster, according to this node.
@@ -94,6 +103,15 @@ type Field struct {
 
 	// Instantiates new translation stores
 	OpenTranslateStore OpenTranslateStoreFunc
+
+	// Used for looking up a foreign index.
+	holder *Holder
+
+	// Stores whether or not the field has keys enabled.
+	// This is most helpful for cases where the keys are
+	// based on a foreign index; this prevents having to
+	// call holder.index.Keys() every time.
+	usesKeys bool
 }
 
 // FieldOption is a functional option type for pilosa.fieldOptions.
@@ -108,6 +126,17 @@ func OptFieldKeys() FieldOption {
 	}
 }
 
+// OptFieldForeignIndex marks this field as a foreign key to another
+// index. That is, the values of this field should be interpreted as
+// referencing records (Pilosa columns) in another index. TODO explain
+// where/how this is used by Pilosa.
+func OptFieldForeignIndex(index string) FieldOption {
+	return func(fo *FieldOptions) error {
+		fo.ForeignIndex = index
+		return nil
+	}
+}
+
 // OptFieldTypeDefault is a functional option on FieldOptions
 // used to set the field type and cache setting to the default values.
 func OptFieldTypeDefault() FieldOption {
@@ -230,6 +259,11 @@ func OptFieldTypeBool() FieldOption {
 }
 
 // NewField returns a new instance of field.
+// NOTE: This function is only used in tests, which is why
+// it only takes a single `FieldOption` (the assumption being
+// that it's of the type `OptFieldType*`). This means
+// this function couldn't be used to set, for example,
+// `FieldOptions.Keys`.
 func NewField(path, index, name string, opts FieldOption) (*Field, error) {
 	err := validateName(name)
 	if err != nil {
@@ -260,7 +294,7 @@ func newField(path, index, name string, opts FieldOption) (*Field, error) {
 		broadcaster: NopBroadcaster,
 		Stats:       stats.NopStatsClient,
 
-		options: applyDefaultOptions(fo),
+		options: *applyDefaultOptions(&fo),
 
 		remoteAvailableShards: roaring.NewBitmap(),
 
@@ -464,7 +498,13 @@ func (f *Field) Open() error {
 			return errors.Wrap(err, "loading available shards")
 		}
 
-		// Apply the field options loaded from meta.
+		// If options were provided using setOptions(), then
+		// use those instead of the options from the meta file.
+		if f.finalOptions != nil {
+			f.options = *f.finalOptions
+		}
+
+		// Apply the field options loaded from meta (or set via setOptions()).
 		f.logger.Debugf("apply options for index/field: %s/%s", f.index, f.name)
 		if err := f.applyOptions(f.options); err != nil {
 			return errors.Wrap(err, "applying options")
@@ -480,9 +520,16 @@ func (f *Field) Open() error {
 			return errors.Wrap(err, "opening attrstore")
 		}
 
-		f.logger.Debugf("open translate store for index/field: %s/%s", f.index, f.name)
-		if f.translateStore, err = f.OpenTranslateStore(f.TranslateStorePath(), f.index, f.name, -1, -1); err != nil {
-			return errors.Wrap(err, "opening field translate store")
+		// If the field has a foreign index, and that index uses keys,
+		// then use that index's translateStore instead.
+		if f.options.ForeignIndex != "" {
+			if err := f.holder.checkForeignIndex(f); err != nil {
+				return errors.Wrap(err, "checking foreign index")
+			}
+		} else {
+			if err := f.applyTranslateStore(); err != nil {
+				return errors.Wrap(err, "applying translate store")
+			}
 		}
 
 		return nil
@@ -495,6 +542,35 @@ func (f *Field) Open() error {
 	return nil
 }
 
+// applyTranslateStore opens the configured translate store.
+func (f *Field) applyTranslateStore() error {
+	// Instantiate & open translation store.
+	var err error
+	f.translateStore, err = f.OpenTranslateStore(f.TranslateStorePath(), f.index, f.name, -1, -1)
+	if err != nil {
+		return errors.Wrap(err, "opening field translate store")
+	}
+	f.usesKeys = f.options.Keys
+	return nil
+}
+
+// applyForeignIndex sets the field's translateStore
+// to that of a foreign index in the case where the
+// foreign index uses keys. If the foreign index does
+// not use keys, it falls back to applying the field's
+// default translate store.
+func (f *Field) applyForeignIndex() error {
+	foreignIndex := f.holder.Index(f.options.ForeignIndex)
+	if foreignIndex == nil {
+		return errors.Wrapf(ErrForeignIndexNotFound, "%s", f.options.ForeignIndex)
+	} else if foreignIndex.Keys() {
+		f.usesKeys = true
+		f.translateStore = foreignIndex.translateStore
+		return nil
+	}
+	return f.applyTranslateStore()
+}
+
 var fieldQueue = make(chan struct{}, 16)
 
 // openViews opens and initializes the views inside the field.
@@ -601,6 +677,7 @@ func (f *Field) loadMeta() error {
 	f.options.TimeQuantum = TimeQuantum(pb.TimeQuantum)
 	f.options.Keys = pb.Keys
 	f.options.NoStandardView = pb.NoStandardView
+	f.options.ForeignIndex = pb.ForeignIndex
 
 	return nil
 }
@@ -631,6 +708,11 @@ func (f *Field) saveMeta() error {
 	return nil
 }
 
+// setOptions saves options for final application during Open().
+func (f *Field) setOptions(opts *FieldOptions) {
+	f.finalOptions = applyDefaultOptions(opts)
+}
+
 // applyOptions configures the field based on opt.
 func (f *Field) applyOptions(opt FieldOptions) error {
 	switch opt.Type {
@@ -654,6 +736,7 @@ func (f *Field) applyOptions(opt FieldOptions) error {
 		f.options.BitDepth = 0
 		f.options.TimeQuantum = ""
 		f.options.Keys = opt.Keys
+		f.options.ForeignIndex = ""
 	case FieldTypeInt, FieldTypeDecimal:
 		f.options.Type = opt.Type
 		f.options.CacheType = CacheTypeNone
@@ -665,6 +748,7 @@ func (f *Field) applyOptions(opt FieldOptions) error {
 		f.options.BitDepth = opt.BitDepth
 		f.options.TimeQuantum = ""
 		f.options.Keys = opt.Keys
+		f.options.ForeignIndex = opt.ForeignIndex
 
 		// Create new bsiGroup.
 		bsig := &bsiGroup{
@@ -698,6 +782,7 @@ func (f *Field) applyOptions(opt FieldOptions) error {
 			f.Close()
 			return errors.Wrap(err, "setting time quantum")
 		}
+		f.options.ForeignIndex = ""
 	case FieldTypeBool:
 		f.options.Type = FieldTypeBool
 		f.options.CacheType = CacheTypeNone
@@ -708,6 +793,7 @@ func (f *Field) applyOptions(opt FieldOptions) error {
 		f.options.BitDepth = 0
 		f.options.TimeQuantum = ""
 		f.options.Keys = false
+		f.options.ForeignIndex = ""
 	default:
 		return errors.New("invalid field type")
 	}
@@ -743,11 +829,11 @@ func (f *Field) Close() error {
 	return nil
 }
 
-// keys returns true if the field uses string keys.
-func (f *Field) keys() bool {
+// Keys returns true if the field uses string keys.
+func (f *Field) Keys() bool {
 	f.mu.RLock()
 	defer f.mu.RUnlock()
-	return f.options.Keys
+	return f.usesKeys
 }
 
 // bsiGroup returns a bsiGroup by name.
@@ -1101,6 +1187,21 @@ func (f *Field) allTimeViewsSortedByQuantum() (me []*view) {
 	return me
 }
 
+// StringValue reads an integer field value for a column, and converts
+// it to a string based on a foreign index string key.
+func (f *Field) StringValue(columnID uint64) (value string, exists bool, err error) {
+	bsig := f.bsiGroup(f.name)
+	if bsig == nil {
+		return value, false, ErrBSIGroupNotFound
+	}
+
+	val, exists, err := f.Value(columnID)
+	if exists {
+		value, err = f.translateStore.TranslateID(uint64(val))
+	}
+	return value, exists, err
+}
+
 // FloatValue reads an integer field value for a column, and converts
 // it to a float based on the configured scale.
 func (f *Field) FloatValue(columnID uint64) (value float64, exists bool, err error) {
@@ -1590,17 +1691,16 @@ type FieldOptions struct {
 	CacheType      string      `json:"cacheType,omitempty"`
 	Type           string      `json:"type,omitempty"`
 	TimeQuantum    TimeQuantum `json:"timeQuantum,omitempty"`
+	ForeignIndex   string      `json:"foreignIndex"`
 }
 
-// applyDefaultOptions returns a new FieldOptions object
-// with default values if o does not contain a valid type.
-func applyDefaultOptions(o FieldOptions) FieldOptions {
+// applyDefaultOptions updates FieldOptions with the default
+// values if o does not contain a valid type.
+func applyDefaultOptions(o *FieldOptions) *FieldOptions {
 	if o.Type == "" {
-		return FieldOptions{
-			Type:      DefaultFieldType,
-			CacheType: DefaultCacheType,
-			CacheSize: DefaultCacheSize,
-		}
+		o.Type = DefaultFieldType
+		o.CacheType = DefaultCacheType
+		o.CacheSize = DefaultCacheSize
 	}
 	return o
 }
@@ -1626,6 +1726,7 @@ func encodeFieldOptions(o *FieldOptions) *internal.FieldOptions {
 		TimeQuantum:    string(o.TimeQuantum),
 		Keys:           o.Keys,
 		NoStandardView: o.NoStandardView,
+		ForeignIndex:   o.ForeignIndex,
 	}
 }
 
@@ -1646,7 +1747,25 @@ func (o *FieldOptions) MarshalJSON() ([]byte, error) {
 			o.CacheSize,
 			o.Keys,
 		})
-	case FieldTypeInt, FieldTypeDecimal:
+	case FieldTypeInt:
+		return json.Marshal(struct {
+			Type         string `json:"type"`
+			Base         int64  `json:"base"`
+			BitDepth     uint   `json:"bitDepth"`
+			Min          int64  `json:"min"`
+			Max          int64  `json:"max"`
+			Keys         bool   `json:"keys"`
+			ForeignIndex string `json:"foreignIndex"`
+		}{
+			o.Type,
+			o.Base,
+			o.BitDepth,
+			o.Min,
+			o.Max,
+			o.Keys,
+			o.ForeignIndex,
+		})
+	case FieldTypeDecimal:
 		return json.Marshal(struct {
 			Type     string `json:"type"`
 			Base     int64  `json:"base"`
diff --git a/field_internal_test.go b/field_internal_test.go
index f400ad3e9..feea5501c 100644
--- a/field_internal_test.go
+++ b/field_internal_test.go
@@ -516,7 +516,7 @@ func TestField_ApplyOptions(t *testing.T) {
 	} {
 
 		fld := &Field{}
-		fld.options = applyDefaultOptions(FieldOptions{})
+		fld.options = *applyDefaultOptions(&FieldOptions{})
 
 		if err := fld.applyOptions(tt.opts); err != nil {
 			t.Fatal(err)
diff --git a/field_test.go b/field_test.go
index 398002ca2..40b64728a 100644
--- a/field_test.go
+++ b/field_test.go
@@ -158,6 +158,7 @@ func TestField_NameValidation(t *testing.T) {
 		"under_score",
 		"abc123",
 		"trailing_",
+		"charact2301234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
 	}
 	invalidFieldNames := []string{
 		"",
@@ -168,7 +169,7 @@ func TestField_NameValidation(t *testing.T) {
 		"abc def",
 		"camelCase",
 		"UPPERCASE",
-		"a12345678901234567890123456789012345678901234567890123456789012345",
+		"charact23112345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901",
 	}
 
 	path, err := ioutil.TempDir("", "pilosa-field-")
diff --git a/fragment_internal_test.go b/fragment_internal_test.go
index f101443ca..dd57635d2 100644
--- a/fragment_internal_test.go
+++ b/fragment_internal_test.go
@@ -3576,3 +3576,47 @@ func TestFragmentConcurrentReadWrite(t *testing.T) {
 
 	t.Logf("%d", acc)
 }
+
+func TestFragment_Bug_Q2DoubleDelete(t *testing.T) {
+	f := mustOpenFragment("i", "f", viewStandard, 0, "")
+	b := []byte{60, 48, 0, 0, 1, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 24, 0, 0, 0, 1, 0}
+	defer f.Clean(t)
+	err := f.importRoaringT(b, false)
+	if err != nil {
+		t.Fatalf("importing roaring: %v", err)
+	}
+	//check the bit
+	res := f.row(1).Columns()
+	if len(res) < 1 || f.row(1).Columns()[0] != 1 {
+		t.Fatalf("expecting 1 got: %v", res)
+	}
+	//clear the bit
+	changed, _ := f.clearBit(1, 1)
+	if !changed {
+		t.Fatalf("expected change got %v", changed)
+	}
+	//check missing
+	res = f.row(1).Columns()
+	if len(res) != 0 {
+		t.Fatalf("expected nothing got %v", res)
+	}
+	// import again
+	err = f.importRoaringT(b, false)
+	if err != nil {
+		t.Fatalf("importing roaring: %v", err)
+	}
+	//check
+	res = f.row(1).Columns()
+	if len(res) < 1 || f.row(1).Columns()[0] != 1 {
+		t.Fatalf("again expecting 1 got: %v", res)
+	}
+	changed, _ = f.clearBit(1, 1)
+	if !changed {
+		t.Fatalf("again expected change got %v", changed)
+	}
+	//check missing
+	res = f.row(1).Columns()
+	if len(res) != 0 {
+		t.Fatalf("expected nothing got %v", res)
+	}
+}
diff --git a/go.mod b/go.mod
index 0c4bb020b..819785c3b 100644
--- a/go.mod
+++ b/go.mod
@@ -15,7 +15,7 @@ require (
 	github.com/gorilla/handlers v1.3.0
 	github.com/gorilla/mux v1.7.0
 	github.com/hashicorp/memberlist v0.1.3
-	github.com/molecula/ext v0.0.0-20191202195653-240f38a75171
+	github.com/molecula/ext v0.0.0-20200103203257-8a458a73e8c2
 	github.com/molecula/extensions v0.0.0-20191218165536-562244600fd4
 	github.com/opentracing/opentracing-go v1.1.0
 	github.com/pelletier/go-toml v1.2.0
diff --git a/go.sum b/go.sum
index f4afb1a6e..54cb1e76e 100644
--- a/go.sum
+++ b/go.sum
@@ -92,6 +92,8 @@ github.com/molecula/apophenia v0.0.0-20190827192002-68b7a14a478b h1:cZADDaNYM7xn
 github.com/molecula/apophenia v0.0.0-20190827192002-68b7a14a478b/go.mod h1:uXd1BiH7xLmgkhVmspdJLENv6uGWrTL/MQX2TN7Yz9s=
 github.com/molecula/ext v0.0.0-20191202195653-240f38a75171 h1:4VK7u/RM+54Yaz8aRB9vIaDSnbKi3M0NQYg5tsZvOT4=
 github.com/molecula/ext v0.0.0-20191202195653-240f38a75171/go.mod h1:r6EIj0GH8dx5xxFLW6Voi1/mX3wXOUkJu6AoEE/xvGQ=
+github.com/molecula/ext v0.0.0-20200103203257-8a458a73e8c2 h1:XOImsA5XhGklFj8Y0TxSm1qWZzEwYxom2JOXiu9GMq0=
+github.com/molecula/ext v0.0.0-20200103203257-8a458a73e8c2/go.mod h1:r6EIj0GH8dx5xxFLW6Voi1/mX3wXOUkJu6AoEE/xvGQ=
 github.com/molecula/extensions v0.0.0-20191218165536-562244600fd4 h1:mDB/dicofRVFuRYcCVPk+JBiVKXlfbzMahuqHvrYqu4=
 github.com/molecula/extensions v0.0.0-20191218165536-562244600fd4/go.mod h1:QQgN5OFjuBAi4Q2UYVMzfvi4k9yvg/qqC+MNFB4I9JI=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
diff --git a/handler.go b/handler.go
index 54444a735..e89791268 100644
--- a/handler.go
+++ b/handler.go
@@ -116,11 +116,12 @@ type ImportValueRequest struct {
 	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
+	Shard        uint64
+	ColumnIDs    []uint64
+	ColumnKeys   []string
+	Values       []int64
+	FloatValues  []float64
+	StringValues []string
 }
 
 func (ivr *ImportValueRequest) Len() int           { return len(ivr.ColumnIDs) }
@@ -131,18 +132,31 @@ func (ivr *ImportValueRequest) Swap(i, j int) {
 		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]
+	} else if len(ivr.StringValues) > 0 {
+		ivr.StringValues[i], ivr.StringValues[j] = ivr.StringValues[j], ivr.StringValues[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)
+// Validate ensures that the payload of the request is valid.
+func (ivr *ImportValueRequest) Validate() error {
+	if ivr.Index == "" || ivr.Field == "" {
+		return errors.Errorf("index and field required, but got '%s' and '%s'", ivr.Index, ivr.Field)
 	}
-	if len(i.ColumnIDs) != 0 && len(i.ColumnKeys) != 0 {
+	if len(ivr.ColumnIDs) != 0 && len(ivr.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")
+	var valueSetCount int
+	if len(ivr.Values) != 0 {
+		valueSetCount++
+	}
+	if len(ivr.FloatValues) != 0 {
+		valueSetCount++
+	}
+	if len(ivr.StringValues) != 0 {
+		valueSetCount++
+	}
+	if valueSetCount > 1 {
+		return errors.Errorf("must pass ints, floats, or strings but not multiple")
 	}
 	return nil
 }
diff --git a/holder.go b/holder.go
index 73e907be8..63ea13896 100644
--- a/holder.go
+++ b/holder.go
@@ -84,6 +84,16 @@ type Holder struct {
 	// Instantiates new translation stores
 	OpenTranslateStore  OpenTranslateStoreFunc
 	OpenTranslateReader OpenTranslateReaderFunc
+
+	// Queue of fields (having a foreign index) which have
+	// opened before their foreign index has opened.
+	foreignIndexFields []*Field
+
+	// opening is set to true while Holder is opening.
+	// It's used to determine if foreign index application
+	// needs to be queued and completed after all indexes
+	// have opened.
+	opening bool
 }
 
 // lockedChan looks a little ridiculous admittedly, but exists for good reason.
@@ -134,6 +144,9 @@ func NewHolder(partitionN int) *Holder {
 
 // Open initializes the root data directory for the holder.
 func (h *Holder) Open() error {
+	h.opening = true
+	defer func() { h.opening = false }()
+
 	// Reset closing in case Holder is being reopened.
 	h.closing = make(chan struct{})
 
@@ -195,6 +208,14 @@ func (h *Holder) Open() error {
 		h.indexes[index.Name()] = index
 		h.mu.Unlock()
 	}
+
+	// If any fields were opened before their foreign index
+	// was opened, it's safe to process those now since all index
+	// opens have completed by this point.
+	if err := h.processForeignIndexFields(); err != nil {
+		return errors.Wrap(err, "processing foreign index fields")
+	}
+
 	h.Logger.Printf("open holder: complete")
 
 	// Periodically flush cache.
@@ -208,6 +229,33 @@ func (h *Holder) Open() error {
 	return nil
 }
 
+// checkForeignIndex is a check before applying a foreign
+// index to a field; if the index is not yet available,
+// (because holder is still opening and may not have opened
+// the index yet), this method queues it up to be processed
+// once all indexes have been opened.
+func (h *Holder) checkForeignIndex(f *Field) error {
+	if h.opening {
+		if fi := h.Index(f.options.ForeignIndex); fi == nil {
+			h.foreignIndexFields = append(h.foreignIndexFields, f)
+			return nil
+		}
+	}
+	return f.applyForeignIndex()
+}
+
+// processForeignIndexFields applies a foreign index to any
+// fields which were opened before their foreign index.
+func (h *Holder) processForeignIndexFields() error {
+	for _, f := range h.foreignIndexFields {
+		if err := f.applyForeignIndex(); err != nil {
+			return errors.Wrap(err, "applying foreign index")
+		}
+	}
+	h.foreignIndexFields = h.foreignIndexFields[:0] // reset
+	return nil
+}
+
 // Close closes all open fragments.
 func (h *Holder) Close() error {
 	h.Stats.Close()
diff --git a/holder_test.go b/holder_test.go
index 09ec03d97..6d2c5f0c7 100644
--- a/holder_test.go
+++ b/holder_test.go
@@ -26,6 +26,7 @@ import (
 
 	"github.com/pilosa/pilosa/v2"
 	"github.com/pilosa/pilosa/v2/test"
+	"github.com/pkg/errors"
 )
 
 func TestHolder_Open(t *testing.T) {
@@ -217,6 +218,64 @@ func TestHolder_Open(t *testing.T) {
 			t.Fatalf("unexpected error: %s", err)
 		}
 	})
+
+	t.Run("ForeignIndex", func(t *testing.T) {
+		t.Run("ErrForeignIndexNotFound", func(t *testing.T) {
+			h := test.MustOpenHolder()
+			defer h.Close()
+
+			if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
+				t.Fatal(err)
+			} else {
+				_, err := idx.CreateField("bar", pilosa.OptFieldTypeInt(0, 100), pilosa.OptFieldForeignIndex("nonexistent"))
+				if err == nil {
+					t.Fatalf("expected error: %s", pilosa.ErrForeignIndexNotFound)
+				} else if errors.Cause(err) != pilosa.ErrForeignIndexNotFound {
+					t.Fatalf("expected error: %s, but got: %s", pilosa.ErrForeignIndexNotFound, err)
+				}
+			}
+		})
+
+		// Foreign index zzz is opened after foo/bar.
+		t.Run("ForeignIndexNotOpenYet", func(t *testing.T) {
+			h := test.MustOpenHolder()
+			defer h.Close()
+
+			if _, err := h.CreateIndex("zzz", pilosa.IndexOptions{}); err != nil {
+				t.Fatal(err)
+			} else if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
+				t.Fatal(err)
+			} else if _, err := idx.CreateField("bar", pilosa.OptFieldTypeInt(0, 100), pilosa.OptFieldForeignIndex("zzz")); err != nil {
+				t.Fatal(err)
+			} else if err := h.Holder.Close(); err != nil {
+				t.Fatal(err)
+			}
+
+			if err := h.Reopen(); err != nil {
+				t.Fatalf("unexpected error: %s", err)
+			}
+		})
+
+		// Foreign index aaa is opened before foo/bar.
+		t.Run("ForeignIndexIsOpen", func(t *testing.T) {
+			h := test.MustOpenHolder()
+			defer h.Close()
+
+			if _, err := h.CreateIndex("aaa", pilosa.IndexOptions{}); err != nil {
+				t.Fatal(err)
+			} else if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
+				t.Fatal(err)
+			} else if _, err := idx.CreateField("bar", pilosa.OptFieldTypeInt(0, 100), pilosa.OptFieldForeignIndex("aaa")); err != nil {
+				t.Fatal(err)
+			} else if err := h.Holder.Close(); err != nil {
+				t.Fatal(err)
+			}
+
+			if err := h.Reopen(); err != nil {
+				t.Fatalf("unexpected error: %s", err)
+			}
+		})
+	})
 }
 
 func TestHolder_HasData(t *testing.T) {
diff --git a/http/handler.go b/http/handler.go
index 375fa09bb..2da97a809 100644
--- a/http/handler.go
+++ b/http/handler.go
@@ -808,6 +808,9 @@ func (h *Handler) handlePostField(w http.ResponseWriter, r *http.Request) {
 			fos = append(fos, pilosa.OptFieldKeys())
 		}
 	}
+	if req.Options.ForeignIndex != nil {
+		fos = append(fos, pilosa.OptFieldForeignIndex(*req.Options.ForeignIndex))
+	}
 
 	_, err = h.api.CreateField(r.Context(), indexName, fieldName, fos...)
 	if _, ok := err.(pilosa.BadRequestError); ok {
@@ -833,6 +836,7 @@ type fieldOptions struct {
 	TimeQuantum    *pilosa.TimeQuantum `json:"timeQuantum,omitempty"`
 	Keys           *bool               `json:"keys,omitempty"`
 	NoStandardView bool                `json:"noStandardView,omitempty"`
+	ForeignIndex   *string             `json:"foreignIndex,omitempty"`
 }
 
 func (o *fieldOptions) validate() error {
@@ -860,6 +864,8 @@ func (o *fieldOptions) validate() error {
 			return pilosa.NewBadRequestError(errors.New("max does not apply to field type set"))
 		} else if o.TimeQuantum != nil {
 			return pilosa.NewBadRequestError(errors.New("timeQuantum does not apply to field type set"))
+		} else if o.ForeignIndex != nil {
+			return pilosa.NewBadRequestError(errors.New("set field cannot be a foreign key"))
 		}
 	case pilosa.FieldTypeInt, pilosa.FieldTypeDecimal:
 		if o.CacheType != nil {
@@ -868,6 +874,8 @@ func (o *fieldOptions) validate() error {
 			return pilosa.NewBadRequestError(errors.New("cacheSize does not apply to field type int"))
 		} else if o.TimeQuantum != nil {
 			return pilosa.NewBadRequestError(errors.New("timeQuantum does not apply to field type int"))
+		} else if o.ForeignIndex != nil && o.Type == pilosa.FieldTypeDecimal {
+			return pilosa.NewBadRequestError(errors.New("decimal field cannot be a foreign key"))
 		}
 	case pilosa.FieldTypeTime:
 		if o.CacheType != nil {
@@ -880,6 +888,8 @@ func (o *fieldOptions) validate() error {
 			return pilosa.NewBadRequestError(errors.New("max does not apply to field type time"))
 		} else if o.TimeQuantum == nil {
 			return pilosa.NewBadRequestError(errors.New("timeQuantum is required for field type time"))
+		} else if o.ForeignIndex != nil {
+			return pilosa.NewBadRequestError(errors.New("time field cannot be a foreign key"))
 		}
 	case pilosa.FieldTypeMutex:
 		if o.CacheType == nil {
@@ -894,6 +904,8 @@ func (o *fieldOptions) validate() error {
 			return pilosa.NewBadRequestError(errors.New("max does not apply to field type mutex"))
 		} else if o.TimeQuantum != nil {
 			return pilosa.NewBadRequestError(errors.New("timeQuantum does not apply to field type mutex"))
+		} else if o.ForeignIndex != nil {
+			return pilosa.NewBadRequestError(errors.New("mutex field cannot be a foreign key"))
 		}
 	case pilosa.FieldTypeBool:
 		if o.CacheType != nil {
@@ -908,6 +920,8 @@ func (o *fieldOptions) validate() error {
 			return pilosa.NewBadRequestError(errors.New("timeQuantum does not apply to field type bool"))
 		} else if o.Keys != nil {
 			return pilosa.NewBadRequestError(errors.New("keys does not apply to field type bool"))
+		} else if o.ForeignIndex != nil {
+			return pilosa.NewBadRequestError(errors.New("bool field cannot be a foreign key"))
 		}
 	default:
 		return errors.Errorf("invalid field type: %s", o.Type)
diff --git a/index.go b/index.go
index c54aa9814..56cbc0de2 100644
--- a/index.go
+++ b/index.go
@@ -63,6 +63,7 @@ type Index struct {
 	snapshotQueue snapshotQueue
 
 	// Used for notifying holder when a field is added.
+	// Also passed to field for foreign-index lookup.
 	holder *Holder
 
 	// Per-partition translation stores
@@ -216,6 +217,10 @@ fileLoop:
 					return errors.Wrapf(ErrName, "'%s'", fi.Name())
 				}
 
+				// Pass holder through to the field for use in looking
+				// up a foreign index.
+				fld.holder = i.holder
+
 				if err := fld.Open(); err != nil {
 					return fmt.Errorf("open field: name=%s, err=%s", fld.Name(), err)
 				}
@@ -447,17 +452,17 @@ func (i *Index) createField(name string, opt FieldOptions) (*Field, error) {
 		return nil, errors.Wrap(err, "initializing")
 	}
 
+	// Pass holder through to the field for use in looking
+	// up a foreign index.
+	f.holder = i.holder
+
+	f.setOptions(&opt)
+
 	// Open field.
 	if err := f.Open(); err != nil {
 		return nil, errors.Wrap(err, "opening")
 	}
 
-	// Apply field options.
-	if err := f.applyOptions(opt); err != nil {
-		f.Close()
-		return nil, errors.Wrap(err, "applying options")
-	}
-
 	if err := f.saveMeta(); err != nil {
 		f.Close()
 		return nil, errors.Wrap(err, "saving meta")
diff --git a/internal/private.pb.go b/internal/private.pb.go
index c941e4dc1..f64f9b5b7 100644
--- a/internal/private.pb.go
+++ b/internal/private.pb.go
@@ -3,13 +3,11 @@
 
 package internal
 
-import (
-	fmt "fmt"
-	proto "github.com/golang/protobuf/proto"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-)
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import io "io"
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
@@ -20,7 +18,7 @@ var _ = math.Inf
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 
 type IndexMeta struct {
 	Keys                 bool     `protobuf:"varint,3,opt,name=Keys,proto3" json:"Keys,omitempty"`
@@ -34,7 +32,7 @@ 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_d2a91b51c7bdc125, []int{0}
+	return fileDescriptor_private_54a82f4803638cdd, []int{0}
 }
 func (m *IndexMeta) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -44,15 +42,15 @@ func (m *IndexMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_IndexMeta.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *IndexMeta) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_IndexMeta.Merge(m, src)
+func (dst *IndexMeta) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_IndexMeta.Merge(dst, src)
 }
 func (m *IndexMeta) XXX_Size() int {
 	return m.Size()
@@ -89,6 +87,7 @@ type FieldOptions struct {
 	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"`
+	ForeignIndex         string   `protobuf:"bytes,16,opt,name=ForeignIndex,proto3" json:"ForeignIndex,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -98,7 +97,7 @@ 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_d2a91b51c7bdc125, []int{1}
+	return fileDescriptor_private_54a82f4803638cdd, []int{1}
 }
 func (m *FieldOptions) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -108,15 +107,15 @@ func (m *FieldOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return xxx_messageInfo_FieldOptions.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *FieldOptions) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FieldOptions.Merge(m, src)
+func (dst *FieldOptions) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FieldOptions.Merge(dst, src)
 }
 func (m *FieldOptions) XXX_Size() int {
 	return m.Size()
@@ -204,6 +203,13 @@ func (m *FieldOptions) GetScale() int64 {
 	return 0
 }
 
+func (m *FieldOptions) GetForeignIndex() string {
+	if m != nil {
+		return m.ForeignIndex
+	}
+	return ""
+}
+
 type ImportResponse struct {
 	Err                  string   `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
@@ -215,7 +221,7 @@ 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_d2a91b51c7bdc125, []int{2}
+	return fileDescriptor_private_54a82f4803638cdd, []int{2}
 }
 func (m *ImportResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -225,15 +231,15 @@ func (m *ImportResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro
 		return xxx_messageInfo_ImportResponse.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *ImportResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ImportResponse.Merge(m, src)
+func (dst *ImportResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ImportResponse.Merge(dst, src)
 }
 func (m *ImportResponse) XXX_Size() int {
 	return m.Size()
@@ -266,7 +272,7 @@ 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_d2a91b51c7bdc125, []int{3}
+	return fileDescriptor_private_54a82f4803638cdd, []int{3}
 }
 func (m *BlockDataRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -276,15 +282,15 @@ func (m *BlockDataRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return xxx_messageInfo_BlockDataRequest.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *BlockDataRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_BlockDataRequest.Merge(m, src)
+func (dst *BlockDataRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BlockDataRequest.Merge(dst, src)
 }
 func (m *BlockDataRequest) XXX_Size() int {
 	return m.Size()
@@ -331,8 +337,8 @@ func (m *BlockDataRequest) GetBlock() uint64 {
 }
 
 type BlockDataResponse struct {
-	RowIDs               []uint64 `protobuf:"varint,1,rep,packed,name=RowIDs,proto3" json:"RowIDs,omitempty"`
-	ColumnIDs            []uint64 `protobuf:"varint,2,rep,packed,name=ColumnIDs,proto3" 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:"-"`
@@ -342,7 +348,7 @@ 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_d2a91b51c7bdc125, []int{4}
+	return fileDescriptor_private_54a82f4803638cdd, []int{4}
 }
 func (m *BlockDataResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -352,15 +358,15 @@ func (m *BlockDataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return xxx_messageInfo_BlockDataResponse.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *BlockDataResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_BlockDataResponse.Merge(m, src)
+func (dst *BlockDataResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BlockDataResponse.Merge(dst, src)
 }
 func (m *BlockDataResponse) XXX_Size() int {
 	return m.Size()
@@ -386,7 +392,7 @@ func (m *BlockDataResponse) GetColumnIDs() []uint64 {
 }
 
 type Cache struct {
-	IDs                  []uint64 `protobuf:"varint,1,rep,packed,name=IDs,proto3" 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:"-"`
@@ -396,7 +402,7 @@ 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_d2a91b51c7bdc125, []int{5}
+	return fileDescriptor_private_54a82f4803638cdd, []int{5}
 }
 func (m *Cache) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -406,15 +412,15 @@ func (m *Cache) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_Cache.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *Cache) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Cache.Merge(m, src)
+func (dst *Cache) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Cache.Merge(dst, src)
 }
 func (m *Cache) XXX_Size() int {
 	return m.Size()
@@ -433,7 +439,7 @@ func (m *Cache) GetIDs() []uint64 {
 }
 
 type MaxShards struct {
-	Standard             map[string]uint64 `protobuf:"bytes,1,rep,name=Standard,proto3" 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:"-"`
@@ -443,7 +449,7 @@ 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_d2a91b51c7bdc125, []int{6}
+	return fileDescriptor_private_54a82f4803638cdd, []int{6}
 }
 func (m *MaxShards) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -453,15 +459,15 @@ func (m *MaxShards) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_MaxShards.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *MaxShards) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MaxShards.Merge(m, src)
+func (dst *MaxShards) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MaxShards.Merge(dst, src)
 }
 func (m *MaxShards) XXX_Size() int {
 	return m.Size()
@@ -492,7 +498,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_d2a91b51c7bdc125, []int{7}
+	return fileDescriptor_private_54a82f4803638cdd, []int{7}
 }
 func (m *CreateShardMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -502,15 +508,15 @@ func (m *CreateShardMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return xxx_messageInfo_CreateShardMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *CreateShardMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CreateShardMessage.Merge(m, src)
+func (dst *CreateShardMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CreateShardMessage.Merge(dst, src)
 }
 func (m *CreateShardMessage) XXX_Size() int {
 	return m.Size()
@@ -553,7 +559,7 @@ 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_d2a91b51c7bdc125, []int{8}
+	return fileDescriptor_private_54a82f4803638cdd, []int{8}
 }
 func (m *DeleteIndexMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -563,15 +569,15 @@ func (m *DeleteIndexMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return xxx_messageInfo_DeleteIndexMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *DeleteIndexMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DeleteIndexMessage.Merge(m, src)
+func (dst *DeleteIndexMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DeleteIndexMessage.Merge(dst, src)
 }
 func (m *DeleteIndexMessage) XXX_Size() int {
 	return m.Size()
@@ -591,7 +597,7 @@ 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,proto3" json:"Meta,omitempty"`
+	Meta                 *IndexMeta `protobuf:"bytes,2,opt,name=Meta" json:"Meta,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
 	XXX_unrecognized     []byte     `json:"-"`
 	XXX_sizecache        int32      `json:"-"`
@@ -601,7 +607,7 @@ 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_d2a91b51c7bdc125, []int{9}
+	return fileDescriptor_private_54a82f4803638cdd, []int{9}
 }
 func (m *CreateIndexMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -611,15 +617,15 @@ func (m *CreateIndexMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return xxx_messageInfo_CreateIndexMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *CreateIndexMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CreateIndexMessage.Merge(m, src)
+func (dst *CreateIndexMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CreateIndexMessage.Merge(dst, src)
 }
 func (m *CreateIndexMessage) XXX_Size() int {
 	return m.Size()
@@ -647,7 +653,7 @@ 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,proto3" json:"Meta,omitempty"`
+	Meta                 *FieldOptions `protobuf:"bytes,3,opt,name=Meta" json:"Meta,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
 	XXX_unrecognized     []byte        `json:"-"`
 	XXX_sizecache        int32         `json:"-"`
@@ -657,7 +663,7 @@ 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_d2a91b51c7bdc125, []int{10}
+	return fileDescriptor_private_54a82f4803638cdd, []int{10}
 }
 func (m *CreateFieldMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -667,15 +673,15 @@ func (m *CreateFieldMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return xxx_messageInfo_CreateFieldMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *CreateFieldMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CreateFieldMessage.Merge(m, src)
+func (dst *CreateFieldMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CreateFieldMessage.Merge(dst, src)
 }
 func (m *CreateFieldMessage) XXX_Size() int {
 	return m.Size()
@@ -719,7 +725,7 @@ 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_d2a91b51c7bdc125, []int{11}
+	return fileDescriptor_private_54a82f4803638cdd, []int{11}
 }
 func (m *DeleteFieldMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -729,15 +735,15 @@ func (m *DeleteFieldMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return xxx_messageInfo_DeleteFieldMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *DeleteFieldMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DeleteFieldMessage.Merge(m, src)
+func (dst *DeleteFieldMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DeleteFieldMessage.Merge(dst, src)
 }
 func (m *DeleteFieldMessage) XXX_Size() int {
 	return m.Size()
@@ -775,7 +781,7 @@ func (m *DeleteAvailableShardMessage) Reset()         { *m = DeleteAvailableShar
 func (m *DeleteAvailableShardMessage) String() string { return proto.CompactTextString(m) }
 func (*DeleteAvailableShardMessage) ProtoMessage()    {}
 func (*DeleteAvailableShardMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d2a91b51c7bdc125, []int{12}
+	return fileDescriptor_private_54a82f4803638cdd, []int{12}
 }
 func (m *DeleteAvailableShardMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -785,15 +791,15 @@ func (m *DeleteAvailableShardMessage) XXX_Marshal(b []byte, deterministic bool)
 		return xxx_messageInfo_DeleteAvailableShardMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *DeleteAvailableShardMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DeleteAvailableShardMessage.Merge(m, src)
+func (dst *DeleteAvailableShardMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DeleteAvailableShardMessage.Merge(dst, src)
 }
 func (m *DeleteAvailableShardMessage) XXX_Size() int {
 	return m.Size()
@@ -827,8 +833,8 @@ 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,proto3" json:"Meta,omitempty"`
-	Views                []string      `protobuf:"bytes,3,rep,name=Views,proto3" json:"Views,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:"-"`
@@ -838,7 +844,7 @@ 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_d2a91b51c7bdc125, []int{13}
+	return fileDescriptor_private_54a82f4803638cdd, []int{13}
 }
 func (m *Field) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -848,15 +854,15 @@ func (m *Field) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_Field.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *Field) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Field.Merge(m, src)
+func (dst *Field) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Field.Merge(dst, src)
 }
 func (m *Field) XXX_Size() int {
 	return m.Size()
@@ -889,7 +895,7 @@ func (m *Field) GetViews() []string {
 }
 
 type Schema struct {
-	Indexes              []*Index `protobuf:"bytes,1,rep,name=Indexes,proto3" 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:"-"`
@@ -899,7 +905,7 @@ 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_d2a91b51c7bdc125, []int{14}
+	return fileDescriptor_private_54a82f4803638cdd, []int{14}
 }
 func (m *Schema) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -909,15 +915,15 @@ func (m *Schema) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_Schema.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *Schema) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Schema.Merge(m, src)
+func (dst *Schema) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Schema.Merge(dst, src)
 }
 func (m *Schema) XXX_Size() int {
 	return m.Size()
@@ -937,7 +943,7 @@ 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,proto3" json:"Fields,omitempty"`
+	Fields               []*Field `protobuf:"bytes,4,rep,name=Fields" json:"Fields,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -947,7 +953,7 @@ 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_d2a91b51c7bdc125, []int{15}
+	return fileDescriptor_private_54a82f4803638cdd, []int{15}
 }
 func (m *Index) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -957,15 +963,15 @@ func (m *Index) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_Index.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *Index) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Index.Merge(m, src)
+func (dst *Index) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Index.Merge(dst, src)
 }
 func (m *Index) XXX_Size() int {
 	return m.Size()
@@ -1003,7 +1009,7 @@ 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_d2a91b51c7bdc125, []int{16}
+	return fileDescriptor_private_54a82f4803638cdd, []int{16}
 }
 func (m *URI) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1013,15 +1019,15 @@ func (m *URI) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_URI.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *URI) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_URI.Merge(m, src)
+func (dst *URI) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_URI.Merge(dst, src)
 }
 func (m *URI) XXX_Size() int {
 	return m.Size()
@@ -1055,7 +1061,7 @@ 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,proto3" json:"URI,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:"-"`
@@ -1067,7 +1073,7 @@ 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_d2a91b51c7bdc125, []int{17}
+	return fileDescriptor_private_54a82f4803638cdd, []int{17}
 }
 func (m *Node) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1077,15 +1083,15 @@ func (m *Node) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_Node.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *Node) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Node.Merge(m, src)
+func (dst *Node) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Node.Merge(dst, src)
 }
 func (m *Node) XXX_Size() int {
 	return m.Size()
@@ -1136,7 +1142,7 @@ 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_d2a91b51c7bdc125, []int{18}
+	return fileDescriptor_private_54a82f4803638cdd, []int{18}
 }
 func (m *NodeStateMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1146,15 +1152,15 @@ func (m *NodeStateMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return xxx_messageInfo_NodeStateMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *NodeStateMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodeStateMessage.Merge(m, src)
+func (dst *NodeStateMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_NodeStateMessage.Merge(dst, src)
 }
 func (m *NodeStateMessage) XXX_Size() int {
 	return m.Size()
@@ -1181,7 +1187,7 @@ 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,proto3" json:"Node,omitempty"`
+	Node                 *Node    `protobuf:"bytes,2,opt,name=Node" json:"Node,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1191,7 +1197,7 @@ 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_d2a91b51c7bdc125, []int{19}
+	return fileDescriptor_private_54a82f4803638cdd, []int{19}
 }
 func (m *NodeEventMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1201,15 +1207,15 @@ func (m *NodeEventMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return xxx_messageInfo_NodeEventMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *NodeEventMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodeEventMessage.Merge(m, src)
+func (dst *NodeEventMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_NodeEventMessage.Merge(dst, src)
 }
 func (m *NodeEventMessage) XXX_Size() int {
 	return m.Size()
@@ -1235,9 +1241,9 @@ func (m *NodeEventMessage) GetNode() *Node {
 }
 
 type NodeStatus struct {
-	Node                 *Node          `protobuf:"bytes,1,opt,name=Node,proto3" json:"Node,omitempty"`
-	Schema               *Schema        `protobuf:"bytes,3,opt,name=Schema,proto3" json:"Schema,omitempty"`
-	Indexes              []*IndexStatus `protobuf:"bytes,4,rep,name=Indexes,proto3" 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:"-"`
@@ -1247,7 +1253,7 @@ 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_d2a91b51c7bdc125, []int{20}
+	return fileDescriptor_private_54a82f4803638cdd, []int{20}
 }
 func (m *NodeStatus) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1257,15 +1263,15 @@ func (m *NodeStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_NodeStatus.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *NodeStatus) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodeStatus.Merge(m, src)
+func (dst *NodeStatus) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_NodeStatus.Merge(dst, src)
 }
 func (m *NodeStatus) XXX_Size() int {
 	return m.Size()
@@ -1299,7 +1305,7 @@ 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,proto3" json:"Fields,omitempty"`
+	Fields               []*FieldStatus `protobuf:"bytes,2,rep,name=Fields" json:"Fields,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
 	XXX_unrecognized     []byte         `json:"-"`
 	XXX_sizecache        int32          `json:"-"`
@@ -1309,7 +1315,7 @@ 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_d2a91b51c7bdc125, []int{21}
+	return fileDescriptor_private_54a82f4803638cdd, []int{21}
 }
 func (m *IndexStatus) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1319,15 +1325,15 @@ func (m *IndexStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return xxx_messageInfo_IndexStatus.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *IndexStatus) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_IndexStatus.Merge(m, src)
+func (dst *IndexStatus) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_IndexStatus.Merge(dst, src)
 }
 func (m *IndexStatus) XXX_Size() int {
 	return m.Size()
@@ -1354,7 +1360,7 @@ 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,proto3" json:"AvailableShards,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:"-"`
@@ -1364,7 +1370,7 @@ 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_d2a91b51c7bdc125, []int{22}
+	return fileDescriptor_private_54a82f4803638cdd, []int{22}
 }
 func (m *FieldStatus) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1374,15 +1380,15 @@ func (m *FieldStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return xxx_messageInfo_FieldStatus.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *FieldStatus) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FieldStatus.Merge(m, src)
+func (dst *FieldStatus) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FieldStatus.Merge(dst, src)
 }
 func (m *FieldStatus) XXX_Size() int {
 	return m.Size()
@@ -1410,7 +1416,7 @@ 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,proto3" json:"Nodes,omitempty"`
+	Nodes                []*Node  `protobuf:"bytes,3,rep,name=Nodes" json:"Nodes,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1420,7 +1426,7 @@ 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_d2a91b51c7bdc125, []int{23}
+	return fileDescriptor_private_54a82f4803638cdd, []int{23}
 }
 func (m *ClusterStatus) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1430,15 +1436,15 @@ func (m *ClusterStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
 		return xxx_messageInfo_ClusterStatus.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *ClusterStatus) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ClusterStatus.Merge(m, src)
+func (dst *ClusterStatus) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ClusterStatus.Merge(dst, src)
 }
 func (m *ClusterStatus) XXX_Size() int {
 	return m.Size()
@@ -1484,7 +1490,7 @@ 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_d2a91b51c7bdc125, []int{24}
+	return fileDescriptor_private_54a82f4803638cdd, []int{24}
 }
 func (m *BSIGroup) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1494,15 +1500,15 @@ func (m *BSIGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_BSIGroup.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *BSIGroup) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_BSIGroup.Merge(m, src)
+func (dst *BSIGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BSIGroup.Merge(dst, src)
 }
 func (m *BSIGroup) XXX_Size() int {
 	return m.Size()
@@ -1554,7 +1560,7 @@ 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_d2a91b51c7bdc125, []int{25}
+	return fileDescriptor_private_54a82f4803638cdd, []int{25}
 }
 func (m *CreateViewMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1564,15 +1570,15 @@ func (m *CreateViewMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return xxx_messageInfo_CreateViewMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *CreateViewMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CreateViewMessage.Merge(m, src)
+func (dst *CreateViewMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CreateViewMessage.Merge(dst, src)
 }
 func (m *CreateViewMessage) XXX_Size() int {
 	return m.Size()
@@ -1617,7 +1623,7 @@ 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_d2a91b51c7bdc125, []int{26}
+	return fileDescriptor_private_54a82f4803638cdd, []int{26}
 }
 func (m *DeleteViewMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1627,15 +1633,15 @@ func (m *DeleteViewMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return xxx_messageInfo_DeleteViewMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *DeleteViewMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DeleteViewMessage.Merge(m, src)
+func (dst *DeleteViewMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DeleteViewMessage.Merge(dst, src)
 }
 func (m *DeleteViewMessage) XXX_Size() int {
 	return m.Size()
@@ -1669,11 +1675,11 @@ 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,proto3" json:"Node,omitempty"`
-	Coordinator          *Node           `protobuf:"bytes,3,opt,name=Coordinator,proto3" json:"Coordinator,omitempty"`
-	Sources              []*ResizeSource `protobuf:"bytes,4,rep,name=Sources,proto3" json:"Sources,omitempty"`
-	NodeStatus           *NodeStatus     `protobuf:"bytes,7,opt,name=NodeStatus,proto3" json:"NodeStatus,omitempty"`
-	ClusterStatus        *ClusterStatus  `protobuf:"bytes,6,opt,name=ClusterStatus,proto3" json:"ClusterStatus,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:"-"`
@@ -1683,7 +1689,7 @@ 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_d2a91b51c7bdc125, []int{27}
+	return fileDescriptor_private_54a82f4803638cdd, []int{27}
 }
 func (m *ResizeInstruction) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1693,15 +1699,15 @@ func (m *ResizeInstruction) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return xxx_messageInfo_ResizeInstruction.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *ResizeInstruction) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ResizeInstruction.Merge(m, src)
+func (dst *ResizeInstruction) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ResizeInstruction.Merge(dst, src)
 }
 func (m *ResizeInstruction) XXX_Size() int {
 	return m.Size()
@@ -1755,7 +1761,7 @@ func (m *ResizeInstruction) GetClusterStatus() *ClusterStatus {
 }
 
 type ResizeSource struct {
-	Node                 *Node    `protobuf:"bytes,1,opt,name=Node,proto3" json:"Node,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"`
@@ -1769,7 +1775,7 @@ 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_d2a91b51c7bdc125, []int{28}
+	return fileDescriptor_private_54a82f4803638cdd, []int{28}
 }
 func (m *ResizeSource) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1779,15 +1785,15 @@ func (m *ResizeSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return xxx_messageInfo_ResizeSource.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *ResizeSource) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ResizeSource.Merge(m, src)
+func (dst *ResizeSource) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ResizeSource.Merge(dst, src)
 }
 func (m *ResizeSource) XXX_Size() int {
 	return m.Size()
@@ -1835,7 +1841,7 @@ 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,proto3" json:"Node,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:"-"`
@@ -1846,7 +1852,7 @@ func (m *ResizeInstructionComplete) Reset()         { *m = ResizeInstructionComp
 func (m *ResizeInstructionComplete) String() string { return proto.CompactTextString(m) }
 func (*ResizeInstructionComplete) ProtoMessage()    {}
 func (*ResizeInstructionComplete) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d2a91b51c7bdc125, []int{29}
+	return fileDescriptor_private_54a82f4803638cdd, []int{29}
 }
 func (m *ResizeInstructionComplete) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1856,15 +1862,15 @@ func (m *ResizeInstructionComplete) XXX_Marshal(b []byte, deterministic bool) ([
 		return xxx_messageInfo_ResizeInstructionComplete.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *ResizeInstructionComplete) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ResizeInstructionComplete.Merge(m, src)
+func (dst *ResizeInstructionComplete) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ResizeInstructionComplete.Merge(dst, src)
 }
 func (m *ResizeInstructionComplete) XXX_Size() int {
 	return m.Size()
@@ -1897,7 +1903,7 @@ func (m *ResizeInstructionComplete) GetError() string {
 }
 
 type SetCoordinatorMessage struct {
-	New                  *Node    `protobuf:"bytes,1,opt,name=New,proto3" 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:"-"`
@@ -1907,7 +1913,7 @@ 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_d2a91b51c7bdc125, []int{30}
+	return fileDescriptor_private_54a82f4803638cdd, []int{30}
 }
 func (m *SetCoordinatorMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1917,15 +1923,15 @@ func (m *SetCoordinatorMessage) XXX_Marshal(b []byte, deterministic bool) ([]byt
 		return xxx_messageInfo_SetCoordinatorMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *SetCoordinatorMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_SetCoordinatorMessage.Merge(m, src)
+func (dst *SetCoordinatorMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SetCoordinatorMessage.Merge(dst, src)
 }
 func (m *SetCoordinatorMessage) XXX_Size() int {
 	return m.Size()
@@ -1944,7 +1950,7 @@ func (m *SetCoordinatorMessage) GetNew() *Node {
 }
 
 type UpdateCoordinatorMessage struct {
-	New                  *Node    `protobuf:"bytes,1,opt,name=New,proto3" 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:"-"`
@@ -1954,7 +1960,7 @@ func (m *UpdateCoordinatorMessage) Reset()         { *m = UpdateCoordinatorMessa
 func (m *UpdateCoordinatorMessage) String() string { return proto.CompactTextString(m) }
 func (*UpdateCoordinatorMessage) ProtoMessage()    {}
 func (*UpdateCoordinatorMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d2a91b51c7bdc125, []int{31}
+	return fileDescriptor_private_54a82f4803638cdd, []int{31}
 }
 func (m *UpdateCoordinatorMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1964,15 +1970,15 @@ func (m *UpdateCoordinatorMessage) XXX_Marshal(b []byte, deterministic bool) ([]
 		return xxx_messageInfo_UpdateCoordinatorMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *UpdateCoordinatorMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_UpdateCoordinatorMessage.Merge(m, src)
+func (dst *UpdateCoordinatorMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UpdateCoordinatorMessage.Merge(dst, src)
 }
 func (m *UpdateCoordinatorMessage) XXX_Size() int {
 	return m.Size()
@@ -1992,7 +1998,7 @@ 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,proto3" json:"NodeIDs,omitempty"`
+	NodeIDs              []string `protobuf:"bytes,2,rep,name=NodeIDs" json:"NodeIDs,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -2002,7 +2008,7 @@ 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_d2a91b51c7bdc125, []int{32}
+	return fileDescriptor_private_54a82f4803638cdd, []int{32}
 }
 func (m *Topology) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2012,15 +2018,15 @@ func (m *Topology) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_Topology.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *Topology) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Topology.Merge(m, src)
+func (dst *Topology) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Topology.Merge(dst, src)
 }
 func (m *Topology) XXX_Size() int {
 	return m.Size()
@@ -2055,7 +2061,7 @@ 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_d2a91b51c7bdc125, []int{33}
+	return fileDescriptor_private_54a82f4803638cdd, []int{33}
 }
 func (m *RecalculateCaches) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2065,15 +2071,15 @@ func (m *RecalculateCaches) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return xxx_messageInfo_RecalculateCaches.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *RecalculateCaches) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_RecalculateCaches.Merge(m, src)
+func (dst *RecalculateCaches) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RecalculateCaches.Merge(dst, src)
 }
 func (m *RecalculateCaches) XXX_Size() int {
 	return m.Size()
@@ -2121,91 +2127,10 @@ func init() {
 	proto.RegisterType((*Topology)(nil), "internal.Topology")
 	proto.RegisterType((*RecalculateCaches)(nil), "internal.RecalculateCaches")
 }
-
-func init() { proto.RegisterFile("private.proto", fileDescriptor_d2a91b51c7bdc125) }
-
-var fileDescriptor_d2a91b51c7bdc125 = []byte{
-	// 1174 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xdb, 0x72, 0xdb, 0x44,
-	0x18, 0x46, 0x87, 0x38, 0xf6, 0xef, 0x38, 0x07, 0xb5, 0x0d, 0x6a, 0x61, 0x82, 0xd9, 0xe9, 0x50,
-	0xd3, 0x19, 0x42, 0xa7, 0xe5, 0x82, 0x53, 0x67, 0x8a, 0xe3, 0x50, 0x44, 0x49, 0x28, 0xeb, 0x24,
-	0x77, 0x5c, 0x6c, 0xec, 0x9d, 0x46, 0x13, 0x59, 0x32, 0xd2, 0x2a, 0x89, 0x7b, 0xc1, 0x2d, 0xcc,
-	0xf0, 0x02, 0x3c, 0x41, 0x9f, 0x85, 0x4b, 0x1e, 0x81, 0x09, 0x2f, 0xc2, 0xec, 0xbf, 0xbb, 0x92,
-	0xec, 0xb8, 0x24, 0x84, 0xde, 0xed, 0xff, 0xfd, 0xfb, 0x9f, 0x0f, 0x5a, 0x41, 0x6b, 0x9c, 0x86,
-	0x27, 0x4c, 0xf0, 0xcd, 0x71, 0x9a, 0x88, 0xc4, 0xab, 0x87, 0xb1, 0xe0, 0x69, 0xcc, 0x22, 0xf2,
-	0x14, 0x1a, 0x41, 0x3c, 0xe4, 0x67, 0x3b, 0x5c, 0x30, 0xcf, 0x03, 0xf7, 0x19, 0x9f, 0x64, 0xbe,
-	0xd3, 0xb6, 0x3a, 0x75, 0x8a, 0x67, 0xef, 0x03, 0x58, 0xde, 0x4b, 0xd9, 0xe0, 0x78, 0xfb, 0x2c,
-	0xcc, 0x04, 0x8f, 0x07, 0xdc, 0x77, 0x91, 0x3b, 0x83, 0x92, 0x57, 0x36, 0x2c, 0x7d, 0x1d, 0xf2,
-	0x68, 0xf8, 0xfd, 0x58, 0x84, 0x49, 0x9c, 0x49, 0x65, 0x7b, 0x93, 0x31, 0xf7, 0xeb, 0x6d, 0xab,
-	0xd3, 0xa0, 0x78, 0xf6, 0xde, 0x85, 0xc6, 0x16, 0x1b, 0x1c, 0x71, 0x64, 0x38, 0xc8, 0x28, 0x81,
-	0x82, 0xdb, 0x0f, 0x5f, 0x2a, 0x2b, 0x2d, 0x5a, 0x02, 0x5e, 0x1b, 0x9a, 0x7b, 0xe1, 0x88, 0xff,
-	0x90, 0xb3, 0x58, 0xe4, 0x23, 0x7f, 0x01, 0xa5, 0xab, 0x90, 0xb7, 0x0a, 0xce, 0x4e, 0x18, 0xfb,
-	0x8d, 0xb6, 0xd5, 0x71, 0xa8, 0x3c, 0x22, 0xc2, 0xce, 0x7c, 0xd0, 0x08, 0x3b, 0x2b, 0x42, 0x6c,
-	0x4e, 0x87, 0xb8, 0x9b, 0xf4, 0x05, 0x8b, 0x87, 0x2c, 0x1d, 0x1e, 0x84, 0xfc, 0xd4, 0x5f, 0x52,
-	0x21, 0x4e, 0xa3, 0x52, 0xb6, 0xcb, 0x32, 0xee, 0xb7, 0x50, 0x1d, 0x9e, 0xbd, 0x3b, 0x50, 0xef,
-	0x86, 0xa2, 0xc7, 0xc7, 0xe2, 0xc8, 0x5f, 0x6e, 0x5b, 0x1d, 0x97, 0x16, 0xb4, 0x77, 0x13, 0x16,
-	0xfa, 0x03, 0x16, 0x71, 0x7f, 0x05, 0x05, 0x14, 0x41, 0x08, 0x2c, 0x07, 0xa3, 0x71, 0x92, 0x0a,
-	0xca, 0xb3, 0x71, 0x12, 0x67, 0x5c, 0x7a, 0xb9, 0x9d, 0xa6, 0xbe, 0x85, 0x11, 0xc9, 0x23, 0xf9,
-	0x19, 0x56, 0xbb, 0x51, 0x32, 0x38, 0xee, 0x31, 0xc1, 0x28, 0xff, 0x29, 0xe7, 0x99, 0x90, 0xda,
-	0xb0, 0x52, 0xfa, 0x9e, 0x22, 0x24, 0x8a, 0x59, 0xf7, 0x6d, 0x85, 0x22, 0x21, 0x3d, 0xc5, 0x38,
-	0x54, 0x92, 0xf0, 0x8c, 0xde, 0x1c, 0xb1, 0x74, 0x88, 0x99, 0x75, 0xa9, 0x22, 0x24, 0x8a, 0x96,
-	0xb0, 0x1a, 0x2e, 0x55, 0x04, 0x09, 0x60, 0xad, 0x62, 0x5f, 0xbb, 0xb9, 0x0e, 0x35, 0x9a, 0x9c,
-	0x06, 0xbd, 0xcc, 0xb7, 0xda, 0x4e, 0xc7, 0xa5, 0x9a, 0xc2, 0xb2, 0x25, 0x51, 0x3e, 0x8a, 0x25,
-	0xcb, 0x46, 0x56, 0x09, 0x90, 0xdb, 0xb0, 0x80, 0x35, 0x94, 0x51, 0x96, 0xb2, 0xf2, 0x48, 0x7e,
-	0xb1, 0xa0, 0xb1, 0xc3, 0xce, 0xd0, 0x91, 0xcc, 0x7b, 0x0c, 0x75, 0x93, 0x6d, 0xbc, 0xd4, 0x7c,
-	0xf8, 0xfe, 0xa6, 0x69, 0xd3, 0xcd, 0xe2, 0xda, 0xa6, 0xb9, 0xb3, 0x1d, 0x8b, 0x74, 0x42, 0x0b,
-	0x91, 0x3b, 0x5f, 0x40, 0x6b, 0x8a, 0x25, 0xed, 0x1d, 0xf3, 0x89, 0xc9, 0xea, 0x31, 0x9f, 0xc8,
-	0x58, 0x4f, 0x58, 0x94, 0x73, 0xcc, 0x95, 0x4b, 0x15, 0xf1, 0xb9, 0xfd, 0xa9, 0x45, 0x0e, 0xc0,
-	0xdb, 0x4a, 0x39, 0x13, 0x1c, 0x8d, 0xec, 0xf0, 0x2c, 0x63, 0x2f, 0xf8, 0x65, 0x19, 0x77, 0xaa,
-	0x19, 0x2f, 0xb2, 0x6b, 0x57, 0xb2, 0x4b, 0xee, 0x83, 0xd7, 0xe3, 0x11, 0x17, 0x5c, 0xcf, 0xd8,
-	0xbf, 0xe8, 0x25, 0x7d, 0xe3, 0xc3, 0xe5, 0x77, 0xbd, 0x7b, 0xe0, 0xca, 0x81, 0x45, 0x63, 0xcd,
-	0x87, 0x37, 0xca, 0x3c, 0x15, 0xb3, 0x4c, 0xf1, 0x02, 0x89, 0x8c, 0x52, 0xf4, 0xf2, 0x8a, 0x81,
-	0x4d, 0xb5, 0xd2, 0x7d, 0x6d, 0xca, 0x41, 0x53, 0xeb, 0xa5, 0xa9, 0xea, 0xb0, 0x6b, 0x6b, 0x4f,
-	0x4c, 0xb8, 0xd7, 0xb5, 0x46, 0x06, 0xf0, 0x8e, 0xd2, 0xf0, 0xd5, 0x09, 0x0b, 0x23, 0x76, 0x18,
-	0xfd, 0xa7, 0x8a, 0x4c, 0x39, 0xee, 0xc3, 0x22, 0xca, 0x06, 0x3d, 0xdd, 0xdb, 0x86, 0x24, 0x3f,
-	0x42, 0x39, 0x26, 0xbb, 0x6c, 0xc4, 0xb5, 0x36, 0x3c, 0x17, 0xf1, 0xda, 0x97, 0xc7, 0x2b, 0x0d,
-	0xcb, 0xd1, 0x92, 0x0b, 0xd3, 0x91, 0x86, 0x91, 0x20, 0x8f, 0xa0, 0xd6, 0x1f, 0x1c, 0xf1, 0x11,
-	0xf3, 0x3e, 0x84, 0x45, 0xf4, 0x90, 0x67, 0xba, 0xa3, 0x57, 0x66, 0x2a, 0x45, 0x0d, 0x9f, 0xf4,
-	0x74, 0x64, 0x73, 0x7d, 0xba, 0x07, 0x35, 0xb4, 0x9e, 0xf9, 0xee, 0xac, 0x1a, 0xc4, 0xa9, 0x66,
-	0x93, 0x6d, 0x70, 0xf6, 0x69, 0x20, 0x27, 0x15, 0x3d, 0x30, 0x5a, 0x34, 0x25, 0x75, 0x7f, 0x93,
-	0x64, 0x42, 0xe7, 0x09, 0xcf, 0x12, 0x7b, 0x9e, 0xa4, 0x02, 0x73, 0xd4, 0xa2, 0x78, 0x26, 0x19,
-	0xb8, 0xbb, 0xc9, 0x90, 0x7b, 0xcb, 0x60, 0x07, 0x3d, 0xad, 0xc3, 0x0e, 0x7a, 0xde, 0x7b, 0xa8,
-	0x5e, 0xa7, 0xa6, 0x55, 0x3a, 0xb1, 0x4f, 0x03, 0x8a, 0x86, 0xef, 0x42, 0x2b, 0xc8, 0xb6, 0x92,
-	0x24, 0x1d, 0x86, 0x31, 0x13, 0x49, 0xaa, 0xbf, 0x24, 0xd3, 0x20, 0xce, 0x8a, 0x60, 0x42, 0xed,
-	0xf8, 0x06, 0x55, 0x04, 0x79, 0x02, 0xab, 0xd2, 0x28, 0x12, 0xa6, 0xde, 0xeb, 0x50, 0x93, 0x58,
-	0xe1, 0x84, 0xa6, 0x4a, 0x0d, 0x76, 0x55, 0xc3, 0x77, 0x4a, 0xc3, 0xf6, 0x09, 0x8f, 0x45, 0xa5,
-	0x63, 0x90, 0x46, 0x05, 0x2d, 0xaa, 0x08, 0x8f, 0xa8, 0x00, 0x75, 0x24, 0xcb, 0x65, 0x24, 0x12,
-	0xa5, 0xc8, 0x23, 0xbf, 0x59, 0x00, 0xc6, 0xa1, 0x3c, 0x2b, 0x44, 0xac, 0xd7, 0x8b, 0x78, 0x1d,
-	0x53, 0x79, 0x3d, 0x2d, 0xab, 0xe5, 0x2d, 0x85, 0x53, 0xd3, 0x19, 0x1f, 0x97, 0x9d, 0xa1, 0x4a,
-	0x7a, 0x6b, 0xa6, 0x33, 0x94, 0xd5, 0xb2, 0x3f, 0x9e, 0x43, 0xb3, 0x82, 0xcf, 0xed, 0x92, 0x8f,
-	0x8a, 0x2e, 0xb1, 0x67, 0x55, 0x22, 0xae, 0x55, 0x9a, 0x5e, 0x79, 0x06, 0xcd, 0x0a, 0x3c, 0x57,
-	0x63, 0x07, 0x56, 0xa6, 0xe7, 0xd0, 0xec, 0xf7, 0x59, 0x98, 0x84, 0xd0, 0xda, 0x8a, 0xf2, 0x4c,
-	0xf0, 0x54, 0xab, 0x93, 0x1f, 0x05, 0x05, 0x14, 0xc5, 0x2b, 0x81, 0xf9, 0xf5, 0xf3, 0xee, 0xc2,
-	0x82, 0x4c, 0xa3, 0x1a, 0xa7, 0x8b, 0x39, 0x56, 0x4c, 0x72, 0x00, 0xf5, 0x6e, 0x3f, 0x78, 0x9a,
-	0x26, 0xf9, 0x78, 0xae, 0xd3, 0xe6, 0xdd, 0x61, 0x57, 0xde, 0x1d, 0xfa, 0x65, 0xe0, 0x5c, 0x78,
-	0x19, 0xb8, 0xc5, 0xcb, 0x80, 0xf4, 0x61, 0x4d, 0xad, 0x4a, 0x39, 0xc5, 0xd7, 0x59, 0x38, 0xe6,
-	0xa3, 0xeb, 0x94, 0x1f, 0x5d, 0xa9, 0x54, 0xed, 0xb3, 0x37, 0xa9, 0xf4, 0x95, 0x0d, 0x6b, 0x94,
-	0x67, 0xe1, 0x4b, 0x1e, 0xc4, 0x99, 0x48, 0xf3, 0x81, 0xdc, 0x49, 0x52, 0xfe, 0xdb, 0xe4, 0x50,
-	0x67, 0xdb, 0xa1, 0x8a, 0xb8, 0x4a, 0xa7, 0x7b, 0x0f, 0xa0, 0x39, 0x3b, 0xb3, 0x17, 0xaf, 0x56,
-	0xaf, 0x78, 0x0f, 0x60, 0xb1, 0x9f, 0xe4, 0xe9, 0xa0, 0x68, 0xdf, 0xca, 0x9e, 0x54, 0x9e, 0x29,
-	0x36, 0x35, 0xd7, 0xbc, 0x4f, 0xaa, 0xc3, 0xe4, 0x2f, 0xa2, 0x89, 0x9b, 0xd3, 0x26, 0x74, 0x7f,
-	0x56, 0x87, 0xee, 0xf1, 0x4c, 0x5b, 0xf9, 0x35, 0x14, 0x7c, 0xbb, 0x14, 0x9c, 0x62, 0xd3, 0xe9,
-	0xdb, 0xe4, 0x57, 0x0b, 0x96, 0xaa, 0xee, 0x5c, 0x69, 0x88, 0x8b, 0xea, 0xd8, 0x97, 0x7f, 0xf5,
-	0x4d, 0x75, 0xdc, 0x79, 0xef, 0xac, 0x85, 0xea, 0x4b, 0xe0, 0x18, 0x6e, 0x5f, 0x28, 0xd9, 0x56,
-	0x32, 0x1a, 0xcb, 0xde, 0xf8, 0x1f, 0xa5, 0x93, 0xeb, 0x2d, 0x4d, 0x75, 0xd1, 0x1a, 0x54, 0x11,
-	0xe4, 0x33, 0xb8, 0xd5, 0xe7, 0xa2, 0x52, 0x30, 0xd3, 0x79, 0x6d, 0x70, 0x76, 0xf9, 0xe9, 0x6b,
-	0xc2, 0x97, 0x2c, 0xf2, 0x25, 0xf8, 0xfb, 0xe3, 0x21, 0x13, 0xfc, 0x5a, 0xd2, 0x5d, 0xa8, 0xef,
-	0x25, 0xe3, 0x24, 0x4a, 0x5e, 0x4c, 0x2e, 0xd9, 0x00, 0x3e, 0x2c, 0xaa, 0x5d, 0xae, 0x56, 0x4a,
-	0x83, 0x1a, 0x92, 0xdc, 0x90, 0xcd, 0x3d, 0x60, 0xd1, 0x20, 0x8f, 0xa4, 0x1b, 0xf2, 0xed, 0x98,
-	0x75, 0x57, 0xff, 0x38, 0xdf, 0xb0, 0xfe, 0x3c, 0xdf, 0xb0, 0xfe, 0x3a, 0xdf, 0xb0, 0x7e, 0xff,
-	0x7b, 0xe3, 0xad, 0xc3, 0x1a, 0xfe, 0xc9, 0x3c, 0xfa, 0x27, 0x00, 0x00, 0xff, 0xff, 0xe1, 0xbf,
-	0xc3, 0x49, 0xda, 0x0c, 0x00, 0x00,
-}
-
 func (m *IndexMeta) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2213,46 +2138,40 @@ func (m *IndexMeta) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *IndexMeta) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *IndexMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if m.TrackExistence {
-		i--
-		if m.TrackExistence {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i--
-		dAtA[i] = 0x20
-	}
 	if m.Keys {
-		i--
+		dAtA[i] = 0x18
+		i++
 		if m.Keys {
 			dAtA[i] = 1
 		} else {
 			dAtA[i] = 0
 		}
-		i--
-		dAtA[i] = 0x18
+		i++
 	}
-	return len(dAtA) - i, nil
+	if m.TrackExistence {
+		dAtA[i] = 0x20
+		i++
+		if m.TrackExistence {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *FieldOptions) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2260,97 +2179,96 @@ func (m *FieldOptions) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *FieldOptions) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *FieldOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.CacheType) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.CacheType)))
+		i += copy(dAtA[i:], m.CacheType)
 	}
-	if m.Scale != 0 {
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Scale))
-		i--
-		dAtA[i] = 0x78
+	if m.CacheSize != 0 {
+		dAtA[i] = 0x20
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.CacheSize))
 	}
-	if m.BitDepth != 0 {
-		i = encodeVarintPrivate(dAtA, i, uint64(m.BitDepth))
-		i--
-		dAtA[i] = 0x70
+	if len(m.TimeQuantum) > 0 {
+		dAtA[i] = 0x2a
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.TimeQuantum)))
+		i += copy(dAtA[i:], m.TimeQuantum)
 	}
-	if m.Base != 0 {
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Base))
-		i--
-		dAtA[i] = 0x68
+	if len(m.Type) > 0 {
+		dAtA[i] = 0x42
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Type)))
+		i += copy(dAtA[i:], m.Type)
 	}
-	if m.NoStandardView {
-		i--
-		if m.NoStandardView {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i--
-		dAtA[i] = 0x60
+	if m.Min != 0 {
+		dAtA[i] = 0x48
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Min))
+	}
+	if m.Max != 0 {
+		dAtA[i] = 0x50
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Max))
 	}
 	if m.Keys {
-		i--
+		dAtA[i] = 0x58
+		i++
 		if m.Keys {
 			dAtA[i] = 1
 		} else {
 			dAtA[i] = 0
 		}
-		i--
-		dAtA[i] = 0x58
+		i++
 	}
-	if m.Max != 0 {
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Max))
-		i--
-		dAtA[i] = 0x50
+	if m.NoStandardView {
+		dAtA[i] = 0x60
+		i++
+		if m.NoStandardView {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
 	}
-	if m.Min != 0 {
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Min))
-		i--
-		dAtA[i] = 0x48
+	if m.Base != 0 {
+		dAtA[i] = 0x68
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Base))
 	}
-	if len(m.Type) > 0 {
-		i -= len(m.Type)
-		copy(dAtA[i:], m.Type)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Type)))
-		i--
-		dAtA[i] = 0x42
+	if m.BitDepth != 0 {
+		dAtA[i] = 0x70
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.BitDepth))
 	}
-	if len(m.TimeQuantum) > 0 {
-		i -= len(m.TimeQuantum)
-		copy(dAtA[i:], m.TimeQuantum)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.TimeQuantum)))
-		i--
-		dAtA[i] = 0x2a
+	if m.Scale != 0 {
+		dAtA[i] = 0x78
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Scale))
 	}
-	if m.CacheSize != 0 {
-		i = encodeVarintPrivate(dAtA, i, uint64(m.CacheSize))
-		i--
-		dAtA[i] = 0x20
+	if len(m.ForeignIndex) > 0 {
+		dAtA[i] = 0x82
+		i++
+		dAtA[i] = 0x1
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.ForeignIndex)))
+		i += copy(dAtA[i:], m.ForeignIndex)
 	}
-	if len(m.CacheType) > 0 {
-		i -= len(m.CacheType)
-		copy(dAtA[i:], m.CacheType)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.CacheType)))
-		i--
-		dAtA[i] = 0x1a
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *ImportResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2358,33 +2276,26 @@ func (m *ImportResponse) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ImportResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ImportResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if len(m.Err) > 0 {
-		i -= len(m.Err)
-		copy(dAtA[i:], m.Err)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Err)))
-		i--
 		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Err)))
+		i += copy(dAtA[i:], m.Err)
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *BlockDataRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2392,57 +2303,48 @@ func (m *BlockDataRequest) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *BlockDataRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *BlockDataRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if len(m.View) > 0 {
-		i -= len(m.View)
-		copy(dAtA[i:], m.View)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.View)))
-		i--
-		dAtA[i] = 0x2a
-	}
-	if m.Shard != 0 {
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Shard))
-		i--
-		dAtA[i] = 0x20
-	}
-	if m.Block != 0 {
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Block))
-		i--
-		dAtA[i] = 0x18
+	if len(m.Index) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
+		i += copy(dAtA[i:], m.Index)
 	}
 	if len(m.Field) > 0 {
-		i -= len(m.Field)
-		copy(dAtA[i:], m.Field)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
-		i--
 		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
+		i += copy(dAtA[i:], m.Field)
 	}
-	if len(m.Index) > 0 {
-		i -= len(m.Index)
-		copy(dAtA[i:], m.Index)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
-		i--
-		dAtA[i] = 0xa
+	if m.Block != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Block))
 	}
-	return len(dAtA) - i, nil
+	if m.Shard != 0 {
+		dAtA[i] = 0x20
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Shard))
+	}
+	if len(m.View) > 0 {
+		dAtA[i] = 0x2a
+		i++
+		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
 }
 
 func (m *BlockDataResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2450,23 +2352,14 @@ func (m *BlockDataResponse) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *BlockDataResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *BlockDataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if len(m.ColumnIDs) > 0 {
-		dAtA2 := make([]byte, len(m.ColumnIDs)*10)
+	if len(m.RowIDs) > 0 {
+		dAtA2 := make([]byte, len(m.RowIDs)*10)
 		var j1 int
-		for _, num := range m.ColumnIDs {
+		for _, num := range m.RowIDs {
 			for num >= 1<<7 {
 				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
@@ -2475,16 +2368,15 @@ func (m *BlockDataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			dAtA2[j1] = uint8(num)
 			j1++
 		}
-		i -= j1
-		copy(dAtA[i:], dAtA2[:j1])
+		dAtA[i] = 0xa
+		i++
 		i = encodeVarintPrivate(dAtA, i, uint64(j1))
-		i--
-		dAtA[i] = 0x12
+		i += copy(dAtA[i:], dAtA2[:j1])
 	}
-	if len(m.RowIDs) > 0 {
-		dAtA4 := make([]byte, len(m.RowIDs)*10)
+	if len(m.ColumnIDs) > 0 {
+		dAtA4 := make([]byte, len(m.ColumnIDs)*10)
 		var j3 int
-		for _, num := range m.RowIDs {
+		for _, num := range m.ColumnIDs {
 			for num >= 1<<7 {
 				dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
@@ -2493,19 +2385,21 @@ func (m *BlockDataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			dAtA4[j3] = uint8(num)
 			j3++
 		}
-		i -= j3
-		copy(dAtA[i:], dAtA4[:j3])
+		dAtA[i] = 0x12
+		i++
 		i = encodeVarintPrivate(dAtA, i, uint64(j3))
-		i--
-		dAtA[i] = 0xa
+		i += copy(dAtA[i:], dAtA4[:j3])
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *Cache) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2513,19 +2407,10 @@ func (m *Cache) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *Cache) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Cache) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if len(m.IDs) > 0 {
 		dAtA6 := make([]byte, len(m.IDs)*10)
 		var j5 int
@@ -2538,19 +2423,21 @@ func (m *Cache) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			dAtA6[j5] = uint8(num)
 			j5++
 		}
-		i -= j5
-		copy(dAtA[i:], dAtA6[:j5])
-		i = encodeVarintPrivate(dAtA, i, uint64(j5))
-		i--
 		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(j5))
+		i += copy(dAtA[i:], dAtA6[:j5])
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *MaxShards) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2558,43 +2445,36 @@ func (m *MaxShards) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *MaxShards) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *MaxShards) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if len(m.Standard) > 0 {
-		for k := range m.Standard {
+		for k, _ := range m.Standard {
+			dAtA[i] = 0xa
+			i++
 			v := m.Standard[k]
-			baseI := i
-			i = encodeVarintPrivate(dAtA, i, uint64(v))
-			i--
-			dAtA[i] = 0x10
-			i -= len(k)
-			copy(dAtA[i:], k)
+			mapSize := 1 + len(k) + sovPrivate(uint64(len(k))) + 1 + sovPrivate(uint64(v))
+			i = encodeVarintPrivate(dAtA, i, uint64(mapSize))
+			dAtA[i] = 0xa
+			i++
 			i = encodeVarintPrivate(dAtA, i, uint64(len(k)))
-			i--
-			dAtA[i] = 0xa
-			i = encodeVarintPrivate(dAtA, i, uint64(baseI-i))
-			i--
-			dAtA[i] = 0xa
+			i += copy(dAtA[i:], k)
+			dAtA[i] = 0x10
+			i++
+			i = encodeVarintPrivate(dAtA, i, uint64(v))
 		}
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *CreateShardMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2602,45 +2482,37 @@ func (m *CreateShardMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *CreateShardMessage) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *CreateShardMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if len(m.Field) > 0 {
-		i -= len(m.Field)
-		copy(dAtA[i:], m.Field)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
-		i--
-		dAtA[i] = 0x1a
+	if len(m.Index) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
+		i += copy(dAtA[i:], m.Index)
 	}
 	if m.Shard != 0 {
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Shard))
-		i--
 		dAtA[i] = 0x10
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Shard))
 	}
-	if len(m.Index) > 0 {
-		i -= len(m.Index)
-		copy(dAtA[i:], m.Index)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
-		i--
-		dAtA[i] = 0xa
+	if len(m.Field) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
+		i += copy(dAtA[i:], m.Field)
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *DeleteIndexMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2648,33 +2520,26 @@ func (m *DeleteIndexMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *DeleteIndexMessage) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *DeleteIndexMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if len(m.Index) > 0 {
-		i -= len(m.Index)
-		copy(dAtA[i:], m.Index)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
-		i--
 		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
+		i += copy(dAtA[i:], m.Index)
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *CreateIndexMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2682,45 +2547,36 @@ func (m *CreateIndexMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *CreateIndexMessage) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *CreateIndexMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Index) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
+		i += copy(dAtA[i:], m.Index)
 	}
 	if m.Meta != nil {
-		{
-			size, err := m.Meta.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintPrivate(dAtA, i, uint64(size))
-		}
-		i--
 		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Meta.Size()))
+		n7, err := m.Meta.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n7
 	}
-	if len(m.Index) > 0 {
-		i -= len(m.Index)
-		copy(dAtA[i:], m.Index)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
-		i--
-		dAtA[i] = 0xa
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *CreateFieldMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2728,52 +2584,42 @@ func (m *CreateFieldMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *CreateFieldMessage) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *CreateFieldMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if m.Meta != nil {
-		{
-			size, err := m.Meta.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintPrivate(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x1a
+	if len(m.Index) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
+		i += copy(dAtA[i:], m.Index)
 	}
 	if len(m.Field) > 0 {
-		i -= len(m.Field)
-		copy(dAtA[i:], m.Field)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
-		i--
 		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
+		i += copy(dAtA[i:], m.Field)
 	}
-	if len(m.Index) > 0 {
-		i -= len(m.Index)
-		copy(dAtA[i:], m.Index)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
-		i--
-		dAtA[i] = 0xa
+	if m.Meta != nil {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Meta.Size()))
+		n8, err := m.Meta.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n8
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *DeleteFieldMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2781,40 +2627,32 @@ func (m *DeleteFieldMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *DeleteFieldMessage) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *DeleteFieldMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Index) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
+		i += copy(dAtA[i:], m.Index)
 	}
 	if len(m.Field) > 0 {
-		i -= len(m.Field)
-		copy(dAtA[i:], m.Field)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
-		i--
 		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
+		i += copy(dAtA[i:], m.Field)
 	}
-	if len(m.Index) > 0 {
-		i -= len(m.Index)
-		copy(dAtA[i:], m.Index)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
-		i--
-		dAtA[i] = 0xa
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *DeleteAvailableShardMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2822,45 +2660,37 @@ func (m *DeleteAvailableShardMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *DeleteAvailableShardMessage) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *DeleteAvailableShardMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if m.ShardID != 0 {
-		i = encodeVarintPrivate(dAtA, i, uint64(m.ShardID))
-		i--
-		dAtA[i] = 0x18
+	if len(m.Index) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
+		i += copy(dAtA[i:], m.Index)
 	}
 	if len(m.Field) > 0 {
-		i -= len(m.Field)
-		copy(dAtA[i:], m.Field)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
-		i--
 		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
+		i += copy(dAtA[i:], m.Field)
 	}
-	if len(m.Index) > 0 {
-		i -= len(m.Index)
-		copy(dAtA[i:], m.Index)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
-		i--
-		dAtA[i] = 0xa
+	if m.ShardID != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.ShardID))
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *Field) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2868,54 +2698,51 @@ func (m *Field) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *Field) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Field) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if len(m.Views) > 0 {
-		for iNdEx := len(m.Views) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.Views[iNdEx])
-			copy(dAtA[i:], m.Views[iNdEx])
-			i = encodeVarintPrivate(dAtA, i, uint64(len(m.Views[iNdEx])))
-			i--
-			dAtA[i] = 0x1a
-		}
+	if len(m.Name) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
 	}
 	if m.Meta != nil {
-		{
-			size, err := m.Meta.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintPrivate(dAtA, i, uint64(size))
-		}
-		i--
 		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Meta.Size()))
+		n9, err := m.Meta.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n9
 	}
-	if len(m.Name) > 0 {
-		i -= len(m.Name)
-		copy(dAtA[i:], m.Name)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Name)))
-		i--
-		dAtA[i] = 0xa
+	if len(m.Views) > 0 {
+		for _, s := range m.Views {
+			dAtA[i] = 0x1a
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
+		}
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *Schema) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2923,40 +2750,32 @@ func (m *Schema) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *Schema) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Schema) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if len(m.Indexes) > 0 {
-		for iNdEx := len(m.Indexes) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Indexes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintPrivate(dAtA, i, uint64(size))
-			}
-			i--
+		for _, msg := range m.Indexes {
 			dAtA[i] = 0xa
+			i++
+			i = encodeVarintPrivate(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
 		}
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *Index) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2964,47 +2783,38 @@ func (m *Index) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *Index) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Index) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Name) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
 	}
 	if len(m.Fields) > 0 {
-		for iNdEx := len(m.Fields) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Fields[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintPrivate(dAtA, i, uint64(size))
-			}
-			i--
+		for _, msg := range m.Fields {
 			dAtA[i] = 0x22
+			i++
+			i = encodeVarintPrivate(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
 		}
 	}
-	if len(m.Name) > 0 {
-		i -= len(m.Name)
-		copy(dAtA[i:], m.Name)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Name)))
-		i--
-		dAtA[i] = 0xa
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *URI) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3012,45 +2822,37 @@ func (m *URI) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *URI) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *URI) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if m.Port != 0 {
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Port))
-		i--
-		dAtA[i] = 0x18
+	if len(m.Scheme) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Scheme)))
+		i += copy(dAtA[i:], m.Scheme)
 	}
 	if len(m.Host) > 0 {
-		i -= len(m.Host)
-		copy(dAtA[i:], m.Host)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Host)))
-		i--
 		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Host)))
+		i += copy(dAtA[i:], m.Host)
 	}
-	if len(m.Scheme) > 0 {
-		i -= len(m.Scheme)
-		copy(dAtA[i:], m.Scheme)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Scheme)))
-		i--
-		dAtA[i] = 0xa
+	if m.Port != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Port))
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *Node) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3058,62 +2860,52 @@ func (m *Node) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *Node) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Node) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.ID) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.ID)))
+		i += copy(dAtA[i:], m.ID)
 	}
-	if len(m.State) > 0 {
-		i -= len(m.State)
-		copy(dAtA[i:], m.State)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.State)))
-		i--
-		dAtA[i] = 0x22
+	if m.URI != nil {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.URI.Size()))
+		n10, err := m.URI.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n10
 	}
 	if m.IsCoordinator {
-		i--
+		dAtA[i] = 0x18
+		i++
 		if m.IsCoordinator {
 			dAtA[i] = 1
 		} else {
 			dAtA[i] = 0
 		}
-		i--
-		dAtA[i] = 0x18
+		i++
 	}
-	if m.URI != nil {
-		{
-			size, err := m.URI.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintPrivate(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x12
+	if len(m.State) > 0 {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.State)))
+		i += copy(dAtA[i:], m.State)
 	}
-	if len(m.ID) > 0 {
-		i -= len(m.ID)
-		copy(dAtA[i:], m.ID)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.ID)))
-		i--
-		dAtA[i] = 0xa
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *NodeStateMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3121,40 +2913,32 @@ func (m *NodeStateMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *NodeStateMessage) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *NodeStateMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.NodeID) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.NodeID)))
+		i += copy(dAtA[i:], m.NodeID)
 	}
 	if len(m.State) > 0 {
-		i -= len(m.State)
-		copy(dAtA[i:], m.State)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.State)))
-		i--
 		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.State)))
+		i += copy(dAtA[i:], m.State)
 	}
-	if len(m.NodeID) > 0 {
-		i -= len(m.NodeID)
-		copy(dAtA[i:], m.NodeID)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.NodeID)))
-		i--
-		dAtA[i] = 0xa
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *NodeEventMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3162,43 +2946,35 @@ func (m *NodeEventMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *NodeEventMessage) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *NodeEventMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
+	if m.Event != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Event))
 	}
 	if m.Node != nil {
-		{
-			size, err := m.Node.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintPrivate(dAtA, i, uint64(size))
-		}
-		i--
 		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Node.Size()))
+		n11, err := m.Node.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n11
 	}
-	if m.Event != 0 {
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Event))
-		i--
-		dAtA[i] = 0x8
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *NodeStatus) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3206,64 +2982,52 @@ func (m *NodeStatus) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *NodeStatus) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *NodeStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if len(m.Indexes) > 0 {
-		for iNdEx := len(m.Indexes) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Indexes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintPrivate(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x22
+	if m.Node != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Node.Size()))
+		n12, err := m.Node.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
 		}
+		i += n12
 	}
 	if m.Schema != nil {
-		{
-			size, err := m.Schema.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintPrivate(dAtA, i, uint64(size))
-		}
-		i--
 		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Schema.Size()))
+		n13, err := m.Schema.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n13
 	}
-	if m.Node != nil {
-		{
-			size, err := m.Node.MarshalToSizedBuffer(dAtA[:i])
+	if len(m.Indexes) > 0 {
+		for _, msg := range m.Indexes {
+			dAtA[i] = 0x22
+			i++
+			i = encodeVarintPrivate(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
 			if err != nil {
 				return 0, err
 			}
-			i -= size
-			i = encodeVarintPrivate(dAtA, i, uint64(size))
+			i += n
 		}
-		i--
-		dAtA[i] = 0xa
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *IndexStatus) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3271,47 +3035,38 @@ func (m *IndexStatus) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *IndexStatus) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *IndexStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Name) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
 	}
 	if len(m.Fields) > 0 {
-		for iNdEx := len(m.Fields) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Fields[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintPrivate(dAtA, i, uint64(size))
-			}
-			i--
+		for _, msg := range m.Fields {
 			dAtA[i] = 0x12
+			i++
+			i = encodeVarintPrivate(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
 		}
 	}
-	if len(m.Name) > 0 {
-		i -= len(m.Name)
-		copy(dAtA[i:], m.Name)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Name)))
-		i--
-		dAtA[i] = 0xa
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *FieldStatus) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3319,18 +3074,15 @@ func (m *FieldStatus) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *FieldStatus) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *FieldStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Name) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
 	}
 	if len(m.AvailableShards) > 0 {
 		dAtA15 := make([]byte, len(m.AvailableShards)*10)
@@ -3344,26 +3096,21 @@ func (m *FieldStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			dAtA15[j14] = uint8(num)
 			j14++
 		}
-		i -= j14
-		copy(dAtA[i:], dAtA15[:j14])
-		i = encodeVarintPrivate(dAtA, i, uint64(j14))
-		i--
 		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(j14))
+		i += copy(dAtA[i:], dAtA15[:j14])
 	}
-	if len(m.Name) > 0 {
-		i -= len(m.Name)
-		copy(dAtA[i:], m.Name)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Name)))
-		i--
-		dAtA[i] = 0xa
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *ClusterStatus) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3371,54 +3118,44 @@ func (m *ClusterStatus) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ClusterStatus) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ClusterStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if len(m.Nodes) > 0 {
-		for iNdEx := len(m.Nodes) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Nodes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintPrivate(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x1a
-		}
+	if len(m.ClusterID) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.ClusterID)))
+		i += copy(dAtA[i:], m.ClusterID)
 	}
 	if len(m.State) > 0 {
-		i -= len(m.State)
-		copy(dAtA[i:], m.State)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.State)))
-		i--
 		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.State)))
+		i += copy(dAtA[i:], m.State)
 	}
-	if len(m.ClusterID) > 0 {
-		i -= len(m.ClusterID)
-		copy(dAtA[i:], m.ClusterID)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.ClusterID)))
-		i--
-		dAtA[i] = 0xa
+	if len(m.Nodes) > 0 {
+		for _, msg := range m.Nodes {
+			dAtA[i] = 0x1a
+			i++
+			i = encodeVarintPrivate(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *BSIGroup) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3426,50 +3163,42 @@ func (m *BSIGroup) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *BSIGroup) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *BSIGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if m.Max != 0 {
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Max))
-		i--
-		dAtA[i] = 0x20
-	}
-	if m.Min != 0 {
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Min))
-		i--
-		dAtA[i] = 0x18
+	if len(m.Name) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
 	}
 	if len(m.Type) > 0 {
-		i -= len(m.Type)
-		copy(dAtA[i:], m.Type)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Type)))
-		i--
 		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Type)))
+		i += copy(dAtA[i:], m.Type)
 	}
-	if len(m.Name) > 0 {
-		i -= len(m.Name)
-		copy(dAtA[i:], m.Name)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Name)))
-		i--
-		dAtA[i] = 0xa
+	if m.Min != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Min))
 	}
-	return len(dAtA) - i, nil
+	if m.Max != 0 {
+		dAtA[i] = 0x20
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Max))
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *CreateViewMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3477,47 +3206,38 @@ func (m *CreateViewMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *CreateViewMessage) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *CreateViewMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if len(m.View) > 0 {
-		i -= len(m.View)
-		copy(dAtA[i:], m.View)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.View)))
-		i--
-		dAtA[i] = 0x1a
+	if len(m.Index) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
+		i += copy(dAtA[i:], m.Index)
 	}
 	if len(m.Field) > 0 {
-		i -= len(m.Field)
-		copy(dAtA[i:], m.Field)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
-		i--
 		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
+		i += copy(dAtA[i:], m.Field)
 	}
-	if len(m.Index) > 0 {
-		i -= len(m.Index)
-		copy(dAtA[i:], m.Index)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
-		i--
-		dAtA[i] = 0xa
+	if len(m.View) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.View)))
+		i += copy(dAtA[i:], m.View)
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *DeleteViewMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3525,47 +3245,38 @@ func (m *DeleteViewMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *DeleteViewMessage) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *DeleteViewMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if len(m.View) > 0 {
-		i -= len(m.View)
-		copy(dAtA[i:], m.View)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.View)))
-		i--
-		dAtA[i] = 0x1a
+	if len(m.Index) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
+		i += copy(dAtA[i:], m.Index)
 	}
 	if len(m.Field) > 0 {
-		i -= len(m.Field)
-		copy(dAtA[i:], m.Field)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
-		i--
 		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
+		i += copy(dAtA[i:], m.Field)
 	}
-	if len(m.Index) > 0 {
-		i -= len(m.Index)
-		copy(dAtA[i:], m.Index)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
-		i--
-		dAtA[i] = 0xa
+	if len(m.View) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.View)))
+		i += copy(dAtA[i:], m.View)
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *ResizeInstruction) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3573,93 +3284,77 @@ func (m *ResizeInstruction) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ResizeInstruction) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ResizeInstruction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if m.NodeStatus != nil {
-		{
-			size, err := m.NodeStatus.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintPrivate(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x3a
-	}
-	if m.ClusterStatus != nil {
-		{
-			size, err := m.ClusterStatus.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintPrivate(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x32
-	}
-	if len(m.Sources) > 0 {
-		for iNdEx := len(m.Sources) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Sources[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintPrivate(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x22
-		}
-	}
-	if m.Coordinator != nil {
-		{
-			size, err := m.Coordinator.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintPrivate(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x1a
+	if m.JobID != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.JobID))
 	}
 	if m.Node != nil {
-		{
-			size, err := m.Node.MarshalToSizedBuffer(dAtA[:i])
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Node.Size()))
+		n16, err := m.Node.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n16
+	}
+	if m.Coordinator != nil {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Coordinator.Size()))
+		n17, err := m.Coordinator.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n17
+	}
+	if len(m.Sources) > 0 {
+		for _, msg := range m.Sources {
+			dAtA[i] = 0x22
+			i++
+			i = encodeVarintPrivate(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
 			if err != nil {
 				return 0, err
 			}
-			i -= size
-			i = encodeVarintPrivate(dAtA, i, uint64(size))
+			i += n
 		}
-		i--
-		dAtA[i] = 0x12
 	}
-	if m.JobID != 0 {
-		i = encodeVarintPrivate(dAtA, i, uint64(m.JobID))
-		i--
-		dAtA[i] = 0x8
+	if m.ClusterStatus != nil {
+		dAtA[i] = 0x32
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.ClusterStatus.Size()))
+		n18, err := m.ClusterStatus.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n18
 	}
-	return len(dAtA) - i, nil
+	if m.NodeStatus != nil {
+		dAtA[i] = 0x3a
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.NodeStatus.Size()))
+		n19, err := m.NodeStatus.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n19
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *ResizeSource) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3667,64 +3362,53 @@ func (m *ResizeSource) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ResizeSource) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ResizeSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if m.Shard != 0 {
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Shard))
-		i--
-		dAtA[i] = 0x28
-	}
-	if len(m.View) > 0 {
-		i -= len(m.View)
-		copy(dAtA[i:], m.View)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.View)))
-		i--
-		dAtA[i] = 0x22
-	}
-	if len(m.Field) > 0 {
-		i -= len(m.Field)
-		copy(dAtA[i:], m.Field)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
-		i--
-		dAtA[i] = 0x1a
+	if m.Node != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Node.Size()))
+		n20, err := m.Node.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n20
 	}
 	if len(m.Index) > 0 {
-		i -= len(m.Index)
-		copy(dAtA[i:], m.Index)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
-		i--
 		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
+		i += copy(dAtA[i:], m.Index)
 	}
-	if m.Node != nil {
-		{
-			size, err := m.Node.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintPrivate(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0xa
+	if len(m.Field) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
+		i += copy(dAtA[i:], m.Field)
 	}
-	return len(dAtA) - i, nil
+	if len(m.View) > 0 {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.View)))
+		i += copy(dAtA[i:], m.View)
+	}
+	if m.Shard != 0 {
+		dAtA[i] = 0x28
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Shard))
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *ResizeInstructionComplete) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3732,50 +3416,41 @@ func (m *ResizeInstructionComplete) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ResizeInstructionComplete) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ResizeInstructionComplete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if len(m.Error) > 0 {
-		i -= len(m.Error)
-		copy(dAtA[i:], m.Error)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Error)))
-		i--
-		dAtA[i] = 0x1a
+	if m.JobID != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.JobID))
 	}
 	if m.Node != nil {
-		{
-			size, err := m.Node.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintPrivate(dAtA, i, uint64(size))
-		}
-		i--
 		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Node.Size()))
+		n21, err := m.Node.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n21
 	}
-	if m.JobID != 0 {
-		i = encodeVarintPrivate(dAtA, i, uint64(m.JobID))
-		i--
-		dAtA[i] = 0x8
+	if len(m.Error) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Error)))
+		i += copy(dAtA[i:], m.Error)
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *SetCoordinatorMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3783,38 +3458,30 @@ func (m *SetCoordinatorMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *SetCoordinatorMessage) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *SetCoordinatorMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if m.New != nil {
-		{
-			size, err := m.New.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintPrivate(dAtA, i, uint64(size))
-		}
-		i--
 		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.New.Size()))
+		n22, err := m.New.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n22
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *UpdateCoordinatorMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3822,38 +3489,30 @@ func (m *UpdateCoordinatorMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *UpdateCoordinatorMessage) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *UpdateCoordinatorMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if m.New != nil {
-		{
-			size, err := m.New.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintPrivate(dAtA, i, uint64(size))
-		}
-		i--
 		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(m.New.Size()))
+		n23, err := m.New.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n23
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *Topology) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3861,42 +3520,41 @@ func (m *Topology) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *Topology) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Topology) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.ClusterID) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.ClusterID)))
+		i += copy(dAtA[i:], m.ClusterID)
 	}
 	if len(m.NodeIDs) > 0 {
-		for iNdEx := len(m.NodeIDs) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.NodeIDs[iNdEx])
-			copy(dAtA[i:], m.NodeIDs[iNdEx])
-			i = encodeVarintPrivate(dAtA, i, uint64(len(m.NodeIDs[iNdEx])))
-			i--
+		for _, s := range m.NodeIDs {
 			dAtA[i] = 0x12
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
 		}
 	}
-	if len(m.ClusterID) > 0 {
-		i -= len(m.ClusterID)
-		copy(dAtA[i:], m.ClusterID)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.ClusterID)))
-		i--
-		dAtA[i] = 0xa
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *RecalculateCaches) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3904,32 +3562,24 @@ func (m *RecalculateCaches) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *RecalculateCaches) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *RecalculateCaches) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
 	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func encodeVarintPrivate(dAtA []byte, offset int, v uint64) int {
-	offset -= sovPrivate(v)
-	base := offset
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
 		v >>= 7
 		offset++
 	}
 	dAtA[offset] = uint8(v)
-	return base
+	return offset + 1
 }
 func (m *IndexMeta) Size() (n int) {
 	if m == nil {
@@ -3991,6 +3641,10 @@ func (m *FieldOptions) Size() (n int) {
 	if m.Scale != 0 {
 		n += 1 + sovPrivate(uint64(m.Scale))
 	}
+	l = len(m.ForeignIndex)
+	if l > 0 {
+		n += 2 + l + sovPrivate(uint64(l))
+	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
 	}
@@ -4718,7 +4372,14 @@ func (m *RecalculateCaches) Size() (n int) {
 }
 
 func sovPrivate(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
 }
 func sozPrivate(x uint64) (n int) {
 	return sovPrivate(uint64((x << 1) ^ uint64((int64(x) >> 63))))
@@ -4738,7 +4399,7 @@ func (m *IndexMeta) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -4766,7 +4427,7 @@ func (m *IndexMeta) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				v |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4786,7 +4447,7 @@ func (m *IndexMeta) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				v |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4801,9 +4462,6 @@ func (m *IndexMeta) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4832,7 +4490,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -4860,7 +4518,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4870,9 +4528,6 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4892,7 +4547,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.CacheSize |= uint32(b&0x7F) << shift
+				m.CacheSize |= (uint32(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4911,7 +4566,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4921,9 +4576,6 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4943,7 +4595,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4953,9 +4605,6 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4975,7 +4624,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Min |= int64(b&0x7F) << shift
+				m.Min |= (int64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4994,7 +4643,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Max |= int64(b&0x7F) << shift
+				m.Max |= (int64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5013,7 +4662,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				v |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5033,7 +4682,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				v |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5053,7 +4702,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Base |= int64(b&0x7F) << shift
+				m.Base |= (int64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5072,7 +4721,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.BitDepth |= uint64(b&0x7F) << shift
+				m.BitDepth |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5091,11 +4740,40 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Scale |= int64(b&0x7F) << shift
+				m.Scale |= (int64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+		case 16:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ForeignIndex", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPrivate
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ForeignIndex = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipPrivate(dAtA[iNdEx:])
@@ -5105,9 +4783,6 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5136,7 +4811,7 @@ func (m *ImportResponse) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5164,7 +4839,7 @@ func (m *ImportResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5174,9 +4849,6 @@ func (m *ImportResponse) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5191,9 +4863,6 @@ func (m *ImportResponse) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5222,7 +4891,7 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5250,7 +4919,7 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5260,9 +4929,6 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5282,7 +4948,7 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5292,9 +4958,6 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5314,7 +4977,7 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Block |= uint64(b&0x7F) << shift
+				m.Block |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5333,7 +4996,7 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Shard |= uint64(b&0x7F) << shift
+				m.Shard |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5352,7 +5015,7 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5362,9 +5025,6 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5379,9 +5039,6 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5410,7 +5067,7 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5436,7 +5093,7 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= uint64(b&0x7F) << shift
+					v |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -5453,7 +5110,7 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= int(b&0x7F) << shift
+					packedLen |= (int(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -5462,15 +5119,12 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPrivate
 				}
 				postIndex := iNdEx + packedLen
-				if postIndex < 0 {
-					return ErrInvalidLengthPrivate
-				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA[iNdEx:postIndex] {
+				for _, integer := range dAtA {
 					if integer < 128 {
 						count++
 					}
@@ -5490,7 +5144,7 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= uint64(b&0x7F) << shift
+						v |= (uint64(b) & 0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -5512,7 +5166,7 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= uint64(b&0x7F) << shift
+					v |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -5529,7 +5183,7 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= int(b&0x7F) << shift
+					packedLen |= (int(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -5538,15 +5192,12 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPrivate
 				}
 				postIndex := iNdEx + packedLen
-				if postIndex < 0 {
-					return ErrInvalidLengthPrivate
-				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA[iNdEx:postIndex] {
+				for _, integer := range dAtA {
 					if integer < 128 {
 						count++
 					}
@@ -5566,7 +5217,7 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= uint64(b&0x7F) << shift
+						v |= (uint64(b) & 0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -5585,9 +5236,6 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5616,7 +5264,7 @@ func (m *Cache) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5642,7 +5290,7 @@ func (m *Cache) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= uint64(b&0x7F) << shift
+					v |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -5659,7 +5307,7 @@ func (m *Cache) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= int(b&0x7F) << shift
+					packedLen |= (int(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -5668,15 +5316,12 @@ func (m *Cache) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPrivate
 				}
 				postIndex := iNdEx + packedLen
-				if postIndex < 0 {
-					return ErrInvalidLengthPrivate
-				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA[iNdEx:postIndex] {
+				for _, integer := range dAtA {
 					if integer < 128 {
 						count++
 					}
@@ -5696,7 +5341,7 @@ func (m *Cache) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= uint64(b&0x7F) << shift
+						v |= (uint64(b) & 0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -5715,9 +5360,6 @@ func (m *Cache) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5746,7 +5388,7 @@ func (m *MaxShards) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5774,7 +5416,7 @@ func (m *MaxShards) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5783,9 +5425,6 @@ func (m *MaxShards) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5806,7 +5445,7 @@ func (m *MaxShards) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					wire |= uint64(b&0x7F) << shift
+					wire |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -5823,7 +5462,7 @@ func (m *MaxShards) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						stringLenmapkey |= uint64(b&0x7F) << shift
+						stringLenmapkey |= (uint64(b) & 0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -5833,9 +5472,6 @@ func (m *MaxShards) Unmarshal(dAtA []byte) error {
 						return ErrInvalidLengthPrivate
 					}
 					postStringIndexmapkey := iNdEx + intStringLenmapkey
-					if postStringIndexmapkey < 0 {
-						return ErrInvalidLengthPrivate
-					}
 					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
@@ -5851,7 +5487,7 @@ func (m *MaxShards) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						mapvalue |= uint64(b&0x7F) << shift
+						mapvalue |= (uint64(b) & 0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -5882,9 +5518,6 @@ func (m *MaxShards) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5913,7 +5546,7 @@ func (m *CreateShardMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5941,7 +5574,7 @@ func (m *CreateShardMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5951,9 +5584,6 @@ func (m *CreateShardMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5973,7 +5603,7 @@ func (m *CreateShardMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Shard |= uint64(b&0x7F) << shift
+				m.Shard |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5992,7 +5622,7 @@ func (m *CreateShardMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6002,9 +5632,6 @@ func (m *CreateShardMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6019,9 +5646,6 @@ func (m *CreateShardMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6050,7 +5674,7 @@ func (m *DeleteIndexMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -6078,7 +5702,7 @@ func (m *DeleteIndexMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6088,9 +5712,6 @@ func (m *DeleteIndexMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6105,9 +5726,6 @@ func (m *DeleteIndexMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6136,7 +5754,7 @@ func (m *CreateIndexMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -6164,7 +5782,7 @@ func (m *CreateIndexMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6174,9 +5792,6 @@ func (m *CreateIndexMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6196,7 +5811,7 @@ func (m *CreateIndexMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6205,9 +5820,6 @@ func (m *CreateIndexMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6227,9 +5839,6 @@ func (m *CreateIndexMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6258,7 +5867,7 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -6286,7 +5895,7 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6296,9 +5905,6 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6318,7 +5924,7 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6328,9 +5934,6 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6350,7 +5953,7 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6359,9 +5962,6 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6381,9 +5981,6 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6412,7 +6009,7 @@ func (m *DeleteFieldMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -6440,7 +6037,7 @@ func (m *DeleteFieldMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6450,9 +6047,6 @@ func (m *DeleteFieldMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6472,7 +6066,7 @@ func (m *DeleteFieldMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6482,9 +6076,6 @@ func (m *DeleteFieldMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6499,9 +6090,6 @@ func (m *DeleteFieldMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6530,7 +6118,7 @@ func (m *DeleteAvailableShardMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -6558,7 +6146,7 @@ func (m *DeleteAvailableShardMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6568,9 +6156,6 @@ func (m *DeleteAvailableShardMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6590,7 +6175,7 @@ func (m *DeleteAvailableShardMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6600,9 +6185,6 @@ func (m *DeleteAvailableShardMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6622,7 +6204,7 @@ func (m *DeleteAvailableShardMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.ShardID |= uint64(b&0x7F) << shift
+				m.ShardID |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6636,9 +6218,6 @@ func (m *DeleteAvailableShardMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6667,7 +6246,7 @@ func (m *Field) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -6695,7 +6274,7 @@ func (m *Field) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6705,9 +6284,6 @@ func (m *Field) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6727,7 +6303,7 @@ func (m *Field) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6736,9 +6312,6 @@ func (m *Field) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6763,7 +6336,7 @@ func (m *Field) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6773,9 +6346,6 @@ func (m *Field) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6790,9 +6360,6 @@ func (m *Field) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6821,7 +6388,7 @@ func (m *Schema) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -6849,7 +6416,7 @@ func (m *Schema) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6858,9 +6425,6 @@ func (m *Schema) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6878,9 +6442,6 @@ func (m *Schema) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6909,7 +6470,7 @@ func (m *Index) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -6937,7 +6498,7 @@ func (m *Index) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6947,9 +6508,6 @@ func (m *Index) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6969,7 +6527,7 @@ func (m *Index) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6978,9 +6536,6 @@ func (m *Index) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6998,9 +6553,6 @@ func (m *Index) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7029,7 +6581,7 @@ func (m *URI) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7057,7 +6609,7 @@ func (m *URI) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7067,9 +6619,6 @@ func (m *URI) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7089,7 +6638,7 @@ func (m *URI) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7099,9 +6648,6 @@ func (m *URI) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7121,7 +6667,7 @@ func (m *URI) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Port |= uint32(b&0x7F) << shift
+				m.Port |= (uint32(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7135,9 +6681,6 @@ func (m *URI) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7166,7 +6709,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7194,7 +6737,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7204,9 +6747,6 @@ func (m *Node) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7226,7 +6766,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7235,9 +6775,6 @@ func (m *Node) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7262,7 +6799,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				v |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7282,7 +6819,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7292,9 +6829,6 @@ func (m *Node) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7309,9 +6843,6 @@ func (m *Node) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7340,7 +6871,7 @@ func (m *NodeStateMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7368,7 +6899,7 @@ func (m *NodeStateMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7378,9 +6909,6 @@ func (m *NodeStateMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7400,7 +6928,7 @@ func (m *NodeStateMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7410,9 +6938,6 @@ func (m *NodeStateMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7427,9 +6952,6 @@ func (m *NodeStateMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7458,7 +6980,7 @@ func (m *NodeEventMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7486,7 +7008,7 @@ func (m *NodeEventMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Event |= uint32(b&0x7F) << shift
+				m.Event |= (uint32(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7505,7 +7027,7 @@ func (m *NodeEventMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7514,9 +7036,6 @@ func (m *NodeEventMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7536,9 +7055,6 @@ func (m *NodeEventMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7567,7 +7083,7 @@ func (m *NodeStatus) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7595,7 +7111,7 @@ func (m *NodeStatus) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7604,9 +7120,6 @@ func (m *NodeStatus) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7631,7 +7144,7 @@ func (m *NodeStatus) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7640,9 +7153,6 @@ func (m *NodeStatus) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7667,7 +7177,7 @@ func (m *NodeStatus) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7676,9 +7186,6 @@ func (m *NodeStatus) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7696,9 +7203,6 @@ func (m *NodeStatus) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7727,7 +7231,7 @@ func (m *IndexStatus) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7755,7 +7259,7 @@ func (m *IndexStatus) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7765,9 +7269,6 @@ func (m *IndexStatus) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7787,7 +7288,7 @@ func (m *IndexStatus) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7796,9 +7297,6 @@ func (m *IndexStatus) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7816,9 +7314,6 @@ func (m *IndexStatus) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7847,7 +7342,7 @@ func (m *FieldStatus) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7875,7 +7370,7 @@ func (m *FieldStatus) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7885,9 +7380,6 @@ func (m *FieldStatus) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7905,7 +7397,7 @@ func (m *FieldStatus) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= uint64(b&0x7F) << shift
+					v |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -7922,7 +7414,7 @@ func (m *FieldStatus) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= int(b&0x7F) << shift
+					packedLen |= (int(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -7931,15 +7423,12 @@ func (m *FieldStatus) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPrivate
 				}
 				postIndex := iNdEx + packedLen
-				if postIndex < 0 {
-					return ErrInvalidLengthPrivate
-				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA[iNdEx:postIndex] {
+				for _, integer := range dAtA {
 					if integer < 128 {
 						count++
 					}
@@ -7959,7 +7448,7 @@ func (m *FieldStatus) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= uint64(b&0x7F) << shift
+						v |= (uint64(b) & 0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -7978,9 +7467,6 @@ func (m *FieldStatus) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8009,7 +7495,7 @@ func (m *ClusterStatus) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -8037,7 +7523,7 @@ func (m *ClusterStatus) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8047,9 +7533,6 @@ func (m *ClusterStatus) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8069,7 +7552,7 @@ func (m *ClusterStatus) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8079,9 +7562,6 @@ func (m *ClusterStatus) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8101,7 +7581,7 @@ func (m *ClusterStatus) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8110,9 +7590,6 @@ func (m *ClusterStatus) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8130,9 +7607,6 @@ func (m *ClusterStatus) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8161,7 +7635,7 @@ func (m *BSIGroup) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -8189,7 +7663,7 @@ func (m *BSIGroup) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8199,9 +7673,6 @@ func (m *BSIGroup) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8221,7 +7692,7 @@ func (m *BSIGroup) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8231,9 +7702,6 @@ func (m *BSIGroup) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8253,7 +7721,7 @@ func (m *BSIGroup) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Min |= int64(b&0x7F) << shift
+				m.Min |= (int64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8272,7 +7740,7 @@ func (m *BSIGroup) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Max |= int64(b&0x7F) << shift
+				m.Max |= (int64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8286,9 +7754,6 @@ func (m *BSIGroup) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8317,7 +7782,7 @@ func (m *CreateViewMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -8345,7 +7810,7 @@ func (m *CreateViewMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8355,9 +7820,6 @@ func (m *CreateViewMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8377,7 +7839,7 @@ func (m *CreateViewMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8387,9 +7849,6 @@ func (m *CreateViewMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8409,7 +7868,7 @@ func (m *CreateViewMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8419,9 +7878,6 @@ func (m *CreateViewMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8436,9 +7892,6 @@ func (m *CreateViewMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8467,7 +7920,7 @@ func (m *DeleteViewMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -8495,7 +7948,7 @@ func (m *DeleteViewMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8505,9 +7958,6 @@ func (m *DeleteViewMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8527,7 +7977,7 @@ func (m *DeleteViewMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8537,9 +7987,6 @@ func (m *DeleteViewMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8559,7 +8006,7 @@ func (m *DeleteViewMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8569,9 +8016,6 @@ func (m *DeleteViewMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8586,9 +8030,6 @@ func (m *DeleteViewMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8617,7 +8058,7 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -8645,7 +8086,7 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.JobID |= int64(b&0x7F) << shift
+				m.JobID |= (int64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8664,7 +8105,7 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8673,9 +8114,6 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8700,7 +8138,7 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8709,9 +8147,6 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8736,7 +8171,7 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8745,9 +8180,6 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8770,7 +8202,7 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8779,9 +8211,6 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8806,7 +8235,7 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8815,9 +8244,6 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8837,9 +8263,6 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8868,7 +8291,7 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -8896,7 +8319,7 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8905,9 +8328,6 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8932,7 +8352,7 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8942,9 +8362,6 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8964,7 +8381,7 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8974,9 +8391,6 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8996,7 +8410,7 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -9006,9 +8420,6 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -9028,7 +8439,7 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Shard |= uint64(b&0x7F) << shift
+				m.Shard |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -9042,9 +8453,6 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -9073,7 +8481,7 @@ func (m *ResizeInstructionComplete) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -9101,7 +8509,7 @@ func (m *ResizeInstructionComplete) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.JobID |= int64(b&0x7F) << shift
+				m.JobID |= (int64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -9120,7 +8528,7 @@ func (m *ResizeInstructionComplete) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -9129,9 +8537,6 @@ func (m *ResizeInstructionComplete) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -9156,7 +8561,7 @@ func (m *ResizeInstructionComplete) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -9166,9 +8571,6 @@ func (m *ResizeInstructionComplete) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -9183,9 +8585,6 @@ func (m *ResizeInstructionComplete) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -9214,7 +8613,7 @@ func (m *SetCoordinatorMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -9242,7 +8641,7 @@ func (m *SetCoordinatorMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -9251,9 +8650,6 @@ func (m *SetCoordinatorMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -9273,9 +8669,6 @@ func (m *SetCoordinatorMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -9304,7 +8697,7 @@ func (m *UpdateCoordinatorMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -9332,7 +8725,7 @@ func (m *UpdateCoordinatorMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -9341,9 +8734,6 @@ func (m *UpdateCoordinatorMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -9363,9 +8753,6 @@ func (m *UpdateCoordinatorMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -9394,7 +8781,7 @@ func (m *Topology) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -9422,7 +8809,7 @@ func (m *Topology) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -9432,9 +8819,6 @@ func (m *Topology) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -9454,7 +8838,7 @@ func (m *Topology) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -9464,9 +8848,6 @@ func (m *Topology) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -9481,9 +8862,6 @@ func (m *Topology) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -9512,7 +8890,7 @@ func (m *RecalculateCaches) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -9535,9 +8913,6 @@ func (m *RecalculateCaches) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPrivate
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -9554,7 +8929,6 @@ func (m *RecalculateCaches) Unmarshal(dAtA []byte) error {
 func skipPrivate(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
-	depth := 0
 	for iNdEx < l {
 		var wire uint64
 		for shift := uint(0); ; shift += 7 {
@@ -9586,8 +8960,10 @@ func skipPrivate(dAtA []byte) (n int, err error) {
 					break
 				}
 			}
+			return iNdEx, nil
 		case 1:
 			iNdEx += 8
+			return iNdEx, nil
 		case 2:
 			var length int
 			for shift := uint(0); ; shift += 7 {
@@ -9604,34 +8980,134 @@ func skipPrivate(dAtA []byte) (n int, err error) {
 					break
 				}
 			}
+			iNdEx += length
 			if length < 0 {
 				return 0, ErrInvalidLengthPrivate
 			}
-			iNdEx += length
+			return iNdEx, nil
 		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupPrivate
+			for {
+				var innerWire uint64
+				var start int = iNdEx
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return 0, ErrIntOverflowPrivate
+					}
+					if iNdEx >= l {
+						return 0, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					innerWire |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				innerWireType := int(innerWire & 0x7)
+				if innerWireType == 4 {
+					break
+				}
+				next, err := skipPrivate(dAtA[start:])
+				if err != nil {
+					return 0, err
+				}
+				iNdEx = start + next
 			}
-			depth--
+			return iNdEx, nil
+		case 4:
+			return iNdEx, nil
 		case 5:
 			iNdEx += 4
+			return iNdEx, nil
 		default:
 			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
 		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthPrivate
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
 	}
-	return 0, io.ErrUnexpectedEOF
+	panic("unreachable")
 }
 
 var (
-	ErrInvalidLengthPrivate        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowPrivate          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupPrivate = fmt.Errorf("proto: unexpected end of group")
+	ErrInvalidLengthPrivate = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowPrivate   = fmt.Errorf("proto: integer overflow")
 )
+
+func init() { proto.RegisterFile("private.proto", fileDescriptor_private_54a82f4803638cdd) }
+
+var fileDescriptor_private_54a82f4803638cdd = []byte{
+	// 1192 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, 0x71, 0xe2, 0x6c, 0xdb, 0xb0, 0x2d, 0x28, 0x98, 0x51, 0x45,
+	0x4d, 0x25, 0x42, 0xd5, 0x72, 0xc1, 0xa9, 0x52, 0x71, 0x9c, 0x96, 0xa5, 0x24, 0x94, 0x71, 0x92,
+	0x3b, 0x2e, 0x26, 0xf6, 0x28, 0x59, 0x65, 0xbd, 0x63, 0x76, 0xc7, 0x49, 0xdc, 0x0b, 0x6e, 0x41,
+	0xe2, 0x05, 0x78, 0x02, 0x9e, 0x05, 0x71, 0xc5, 0x23, 0xa0, 0xf0, 0x22, 0x68, 0xfe, 0x99, 0x3d,
+	0xd8, 0x71, 0x48, 0x14, 0x7a, 0x37, 0xff, 0xf9, 0xf0, 0xfd, 0xff, 0xec, 0x2c, 0x34, 0x46, 0x49,
+	0x78, 0xc2, 0x24, 0xdf, 0x18, 0x25, 0x42, 0x0a, 0xaf, 0x1a, 0xc6, 0x92, 0x27, 0x31, 0x8b, 0xc8,
+	0x0b, 0xa8, 0x05, 0xf1, 0x80, 0x9f, 0x6d, 0x73, 0xc9, 0x3c, 0x0f, 0xdc, 0x97, 0x7c, 0x92, 0xfa,
+	0x4e, 0xcb, 0x6a, 0x57, 0x29, 0x9e, 0xbd, 0x0f, 0x60, 0x79, 0x37, 0x61, 0xfd, 0xe3, 0xad, 0xb3,
+	0x30, 0x95, 0x3c, 0xee, 0x73, 0xdf, 0x45, 0xe9, 0x0c, 0x97, 0xfc, 0x69, 0xc3, 0xd2, 0xf3, 0x90,
+	0x47, 0x83, 0xef, 0x46, 0x32, 0x14, 0x71, 0xea, 0xbd, 0x0b, 0xb5, 0x4d, 0xd6, 0x3f, 0xe2, 0xbb,
+	0x93, 0x11, 0x47, 0x8f, 0x35, 0x5a, 0x30, 0x72, 0x69, 0x2f, 0x7c, 0xad, 0x3d, 0x36, 0x68, 0xc1,
+	0xf0, 0x5a, 0x50, 0xdf, 0x0d, 0x87, 0xfc, 0xfb, 0x31, 0x8b, 0xe5, 0x78, 0xe8, 0x2f, 0xa0, 0x75,
+	0x99, 0xa5, 0x52, 0x45, 0xc7, 0x55, 0x14, 0xe1, 0xd9, 0x6b, 0x82, 0xb3, 0x1d, 0xc6, 0x7e, 0xad,
+	0x65, 0xb5, 0x1d, 0xaa, 0x8e, 0xc8, 0x61, 0x67, 0x3e, 0x18, 0x0e, 0x3b, 0xcb, 0x4b, 0xac, 0x4f,
+	0x97, 0xb8, 0x23, 0x7a, 0x92, 0xc5, 0x03, 0x96, 0x0c, 0xf6, 0x43, 0x7e, 0xea, 0x2f, 0xe9, 0x12,
+	0xa7, 0xb9, 0xca, 0xb6, 0xc3, 0x52, 0xee, 0x37, 0xd0, 0x1d, 0x9e, 0xbd, 0x7b, 0x50, 0xed, 0x84,
+	0xb2, 0xcb, 0x47, 0xf2, 0xc8, 0x5f, 0x6e, 0x59, 0x6d, 0x97, 0xe6, 0xb4, 0x77, 0x1b, 0x16, 0x7a,
+	0x7d, 0x16, 0x71, 0x7f, 0x05, 0x0d, 0x34, 0xe1, 0x11, 0x58, 0x7a, 0x2e, 0x12, 0x1e, 0x1e, 0xc6,
+	0xd8, 0x78, 0xbf, 0x89, 0x15, 0x4c, 0xf1, 0x08, 0x81, 0xe5, 0x60, 0x38, 0x12, 0x89, 0xa4, 0x3c,
+	0x1d, 0x89, 0x38, 0xc5, 0xda, 0xb6, 0x92, 0xc4, 0xb7, 0x50, 0x59, 0x1d, 0xc9, 0x4f, 0xd0, 0xec,
+	0x44, 0xa2, 0x7f, 0xdc, 0x65, 0x92, 0x51, 0xfe, 0xe3, 0x98, 0xa7, 0x52, 0x45, 0xd4, 0x4e, 0xb5,
+	0x9e, 0x26, 0x14, 0x17, 0x91, 0xf1, 0x6d, 0xcd, 0x45, 0x42, 0x71, 0xd1, 0x1e, 0xb1, 0x71, 0xa9,
+	0x26, 0x30, 0xe7, 0x23, 0x96, 0x0c, 0x10, 0x13, 0x97, 0x6a, 0x42, 0x55, 0x8e, 0x7d, 0xd1, 0x40,
+	0xe0, 0x99, 0x04, 0xb0, 0x5a, 0x8a, 0x6f, 0xd2, 0x5c, 0x83, 0x0a, 0x15, 0xa7, 0x41, 0x37, 0xf5,
+	0xad, 0x96, 0xd3, 0x76, 0xa9, 0xa1, 0x10, 0x6e, 0x11, 0x8d, 0x87, 0xb1, 0x12, 0xd9, 0x28, 0x2a,
+	0x18, 0xe4, 0x2e, 0x2c, 0x20, 0xf6, 0xaa, 0xca, 0xc2, 0x56, 0x1d, 0xc9, 0xcf, 0x16, 0xd4, 0xb6,
+	0xd9, 0x19, 0xa6, 0x91, 0x7a, 0x4f, 0xa1, 0x9a, 0x21, 0x82, 0x4a, 0xf5, 0xc7, 0xef, 0x6f, 0x64,
+	0xa3, 0xbc, 0x91, 0xab, 0x6d, 0x64, 0x3a, 0x5b, 0xb1, 0x4c, 0x26, 0x34, 0x37, 0xb9, 0xf7, 0x05,
+	0x34, 0xa6, 0x44, 0x2a, 0xde, 0x31, 0x9f, 0x64, 0x5d, 0x3d, 0xe6, 0x13, 0x55, 0xff, 0x09, 0x8b,
+	0xc6, 0x1c, 0x7b, 0xe5, 0x52, 0x4d, 0x7c, 0x6e, 0x7f, 0x6a, 0x91, 0x7d, 0xf0, 0x36, 0x13, 0xce,
+	0x24, 0xc7, 0x20, 0xdb, 0x3c, 0x4d, 0xd9, 0x21, 0xbf, 0xbc, 0xe3, 0xba, 0x8b, 0x76, 0xb9, 0x8b,
+	0x39, 0x0e, 0x4e, 0x09, 0x07, 0xf2, 0x10, 0xbc, 0x2e, 0x8f, 0xb8, 0xe4, 0x66, 0x0f, 0xff, 0xc3,
+	0x2f, 0xe9, 0x65, 0x39, 0x5c, 0xad, 0xeb, 0x3d, 0x00, 0x57, 0x2d, 0x35, 0xa6, 0x50, 0x7f, 0x7c,
+	0xab, 0xe8, 0x53, 0xbe, 0xef, 0x14, 0x15, 0x48, 0x94, 0x39, 0xc5, 0x7c, 0xae, 0x2c, 0x6c, 0xce,
+	0x28, 0x3d, 0x34, 0xa1, 0x1c, 0x0c, 0xb5, 0x56, 0x84, 0x2a, 0x5f, 0x08, 0x26, 0xda, 0xb3, 0xac,
+	0xdc, 0x9b, 0x46, 0x23, 0x7d, 0x78, 0x47, 0x7b, 0xf8, 0xea, 0x84, 0x85, 0x11, 0x3b, 0x88, 0xae,
+	0x89, 0xc8, 0x9c, 0xc4, 0x7d, 0x58, 0x44, 0xdb, 0xa0, 0x6b, 0xb6, 0x20, 0x23, 0xc9, 0x0f, 0x46,
+	0x5f, 0x8d, 0xfe, 0x0e, 0x1b, 0x72, 0xe3, 0x0d, 0xcf, 0x79, 0xbd, 0xf6, 0xd5, 0xf5, 0xaa, 0xc0,
+	0x6a, 0x5d, 0xd4, 0xa5, 0xea, 0xa8, 0xc0, 0x48, 0x90, 0x27, 0x50, 0xe9, 0xf5, 0x8f, 0xf8, 0x90,
+	0x79, 0x1f, 0xc2, 0x22, 0x66, 0xc8, 0x53, 0x33, 0xd1, 0x2b, 0x33, 0x48, 0xd1, 0x4c, 0x4e, 0xba,
+	0xa6, 0xb2, 0xb9, 0x39, 0x3d, 0x80, 0x0a, 0x46, 0x4f, 0x7d, 0x77, 0xd6, 0x0d, 0xf2, 0xa9, 0x11,
+	0x93, 0x2d, 0x70, 0xf6, 0x68, 0xa0, 0x36, 0x15, 0x33, 0xc8, 0xbc, 0x18, 0x4a, 0xf9, 0xfe, 0x5a,
+	0xa4, 0xd2, 0xf4, 0x09, 0xcf, 0x8a, 0xf7, 0x4a, 0x24, 0x12, 0x7b, 0xd4, 0xa0, 0x78, 0x26, 0x29,
+	0xb8, 0x3b, 0x62, 0xc0, 0xbd, 0x65, 0xb0, 0x83, 0xae, 0xf1, 0x61, 0x07, 0x5d, 0xef, 0x3d, 0x74,
+	0x6f, 0x5a, 0xd3, 0x28, 0x92, 0xd8, 0xa3, 0x01, 0xc5, 0xc0, 0xf7, 0xa1, 0x11, 0xa4, 0x9b, 0x42,
+	0x24, 0x83, 0x30, 0x66, 0x52, 0x24, 0xe6, 0x6b, 0x33, 0xcd, 0xc4, 0x0d, 0x92, 0x4c, 0xea, 0x6f,
+	0x43, 0x8d, 0x6a, 0x82, 0x3c, 0x83, 0xa6, 0x0a, 0x8a, 0x44, 0x86, 0xf7, 0x1a, 0x54, 0x14, 0x2f,
+	0x4f, 0xc2, 0x50, 0x85, 0x07, 0xbb, 0xec, 0xe1, 0x5b, 0xed, 0x61, 0xeb, 0x84, 0xc7, 0xb2, 0x34,
+	0x31, 0x48, 0xa3, 0x83, 0x06, 0xd5, 0x84, 0x47, 0x74, 0x81, 0xa6, 0x92, 0xe5, 0xa2, 0x12, 0xc5,
+	0xa5, 0x28, 0x23, 0xbf, 0x5a, 0x00, 0x59, 0x42, 0xe3, 0x34, 0x37, 0xb1, 0x2e, 0x37, 0xf1, 0xda,
+	0x19, 0xf2, 0x66, 0x5b, 0x9a, 0x85, 0x96, 0xe6, 0xd3, 0x6c, 0x32, 0x3e, 0x2e, 0x26, 0x43, 0x43,
+	0x7a, 0x67, 0x66, 0x32, 0x74, 0xd4, 0x62, 0x3e, 0x5e, 0x41, 0xbd, 0xc4, 0x9f, 0x3b, 0x25, 0x1f,
+	0xe5, 0x53, 0x62, 0xcf, 0xba, 0x44, 0xbe, 0x71, 0x99, 0xcd, 0xca, 0x4b, 0xa8, 0x97, 0xd8, 0x73,
+	0x3d, 0xb6, 0x61, 0x65, 0x7a, 0x0f, 0xb3, 0xfb, 0x7d, 0x96, 0x4d, 0x42, 0x68, 0x6c, 0x46, 0xe3,
+	0x54, 0xf2, 0xc4, 0xb8, 0x53, 0x1f, 0x05, 0xcd, 0xc8, 0xc1, 0x2b, 0x18, 0xf3, 0xf1, 0xf3, 0xee,
+	0xc3, 0x82, 0x6a, 0xa3, 0x5e, 0xa7, 0x8b, 0x3d, 0xd6, 0x42, 0xb2, 0x0f, 0xd5, 0x4e, 0x2f, 0x78,
+	0x91, 0x88, 0xf1, 0x68, 0x6e, 0xd2, 0xd9, 0xeb, 0xc1, 0xbe, 0xf8, 0x7a, 0x70, 0x2e, 0xbc, 0x1e,
+	0xdc, 0xfc, 0xf5, 0x40, 0x7a, 0xb0, 0xaa, 0xaf, 0x4a, 0xb5, 0xc5, 0x37, 0xb9, 0x70, 0xb2, 0x0f,
+	0xa9, 0x53, 0xfa, 0x90, 0xf6, 0x60, 0x55, 0xdf, 0x67, 0x6f, 0xd2, 0xe9, 0xef, 0x36, 0xac, 0x52,
+	0x9e, 0x86, 0xaf, 0x79, 0x10, 0xa7, 0x32, 0x19, 0xf7, 0xd5, 0x9d, 0xa4, 0xec, 0xbf, 0x11, 0x07,
+	0xa6, 0xdb, 0x0e, 0xd5, 0xc4, 0x75, 0x26, 0xdd, 0x7b, 0x04, 0xf5, 0xd9, 0x9d, 0xbd, 0xa8, 0x5a,
+	0x56, 0xf1, 0x1e, 0xc1, 0x62, 0x4f, 0x8c, 0x93, 0x7e, 0x3e, 0xbe, 0xa5, 0x7b, 0x52, 0x67, 0xa6,
+	0xc5, 0x34, 0x53, 0xf3, 0x9e, 0xce, 0x0c, 0x88, 0x5f, 0xc1, 0x28, 0x6f, 0x17, 0x76, 0x53, 0x62,
+	0x3a, 0x33, 0x4e, 0x9f, 0x94, 0x77, 0xd1, 0x5f, 0x44, 0xdb, 0xdb, 0xd3, 0x19, 0x1a, 0xc3, 0x92,
+	0x1e, 0xf9, 0xc5, 0x82, 0xa5, 0x72, 0x3a, 0xd7, 0x5a, 0xe2, 0x1c, 0x1d, 0x7b, 0x2e, 0x3a, 0xce,
+	0x3c, 0x74, 0xdc, 0x02, 0x9d, 0xe2, 0x7d, 0xb0, 0x50, 0x7a, 0x1f, 0x90, 0x63, 0xb8, 0x7b, 0x01,
+	0xb2, 0x4d, 0x31, 0x1c, 0xa9, 0xd9, 0xf8, 0x1f, 0xd0, 0xa9, 0xeb, 0x2d, 0x49, 0x0c, 0x68, 0x35,
+	0xaa, 0x09, 0xf2, 0x19, 0xdc, 0xe9, 0x71, 0x59, 0x02, 0x2c, 0x9b, 0xbc, 0x16, 0x38, 0x3b, 0xfc,
+	0xf4, 0x92, 0xf2, 0x95, 0x88, 0x7c, 0x09, 0xfe, 0xde, 0x68, 0xc0, 0x24, 0xbf, 0x91, 0x75, 0x07,
+	0xaa, 0xbb, 0x62, 0x24, 0x22, 0x71, 0x38, 0xb9, 0xe2, 0x06, 0xf0, 0x61, 0x51, 0xdf, 0xe5, 0xfa,
+	0x4a, 0xa9, 0xd1, 0x8c, 0x24, 0xb7, 0xd4, 0x70, 0xf7, 0x59, 0xd4, 0x1f, 0x47, 0x2a, 0x0d, 0xf5,
+	0x76, 0x4c, 0x3b, 0xcd, 0x3f, 0xce, 0xd7, 0xad, 0xbf, 0xce, 0xd7, 0xad, 0xbf, 0xcf, 0xd7, 0xad,
+	0xdf, 0xfe, 0x59, 0x7f, 0xeb, 0xa0, 0x82, 0x7f, 0x3b, 0x4f, 0xfe, 0x0d, 0x00, 0x00, 0xff, 0xff,
+	0xf4, 0x25, 0x10, 0xc0, 0xfe, 0x0c, 0x00, 0x00,
+}
diff --git a/internal/private.proto b/internal/private.proto
index d36527f63..381fe5adb 100644
--- a/internal/private.proto
+++ b/internal/private.proto
@@ -19,6 +19,7 @@ message FieldOptions {
 	int64 Base = 13;
 	uint64 BitDepth = 14;
 	int64 Scale = 15;
+	string ForeignIndex = 16;
 }
 
 message ImportResponse {
diff --git a/internal/public.pb.go b/internal/public.pb.go
index dfae6c59c..514d3ad25 100644
--- a/internal/public.pb.go
+++ b/internal/public.pb.go
@@ -3,14 +3,13 @@
 
 package internal
 
-import (
-	encoding_binary "encoding/binary"
-	fmt "fmt"
-	proto "github.com/golang/protobuf/proto"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-)
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import encoding_binary "encoding/binary"
+
+import io "io"
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
@@ -21,12 +20,12 @@ var _ = math.Inf
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 
 type Row struct {
-	Columns              []uint64 `protobuf:"varint,1,rep,packed,name=Columns,proto3" json:"Columns,omitempty"`
-	Keys                 []string `protobuf:"bytes,3,rep,name=Keys,proto3" json:"Keys,omitempty"`
-	Attrs                []*Attr  `protobuf:"bytes,2,rep,name=Attrs,proto3" 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"`
 	Roaring              []byte   `protobuf:"bytes,4,opt,name=Roaring,proto3" json:"Roaring,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
@@ -37,7 +36,7 @@ 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_413a91106d7bcce8, []int{0}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{0}
 }
 func (m *Row) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -47,15 +46,15 @@ func (m *Row) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_Row.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *Row) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Row.Merge(m, src)
+func (dst *Row) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Row.Merge(dst, src)
 }
 func (m *Row) XXX_Size() int {
 	return m.Size()
@@ -95,8 +94,8 @@ func (m *Row) GetRoaring() []byte {
 }
 
 type SignedRow struct {
-	Pos                  *Row     `protobuf:"bytes,1,opt,name=Pos,proto3" json:"Pos,omitempty"`
-	Neg                  *Row     `protobuf:"bytes,2,opt,name=Neg,proto3" json:"Neg,omitempty"`
+	Pos                  *Row     `protobuf:"bytes,1,opt,name=Pos" json:"Pos,omitempty"`
+	Neg                  *Row     `protobuf:"bytes,2,opt,name=Neg" json:"Neg,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -106,7 +105,7 @@ func (m *SignedRow) Reset()         { *m = SignedRow{} }
 func (m *SignedRow) String() string { return proto.CompactTextString(m) }
 func (*SignedRow) ProtoMessage()    {}
 func (*SignedRow) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{1}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{1}
 }
 func (m *SignedRow) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -116,15 +115,15 @@ func (m *SignedRow) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_SignedRow.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *SignedRow) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_SignedRow.Merge(m, src)
+func (dst *SignedRow) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SignedRow.Merge(dst, src)
 }
 func (m *SignedRow) XXX_Size() int {
 	return m.Size()
@@ -150,8 +149,8 @@ func (m *SignedRow) GetNeg() *Row {
 }
 
 type RowIdentifiers struct {
-	Rows                 []uint64 `protobuf:"varint,1,rep,packed,name=Rows,proto3" json:"Rows,omitempty"`
-	Keys                 []string `protobuf:"bytes,2,rep,name=Keys,proto3" 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:"-"`
@@ -161,7 +160,7 @@ 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_413a91106d7bcce8, []int{2}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{2}
 }
 func (m *RowIdentifiers) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -171,15 +170,15 @@ func (m *RowIdentifiers) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro
 		return xxx_messageInfo_RowIdentifiers.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *RowIdentifiers) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_RowIdentifiers.Merge(m, src)
+func (dst *RowIdentifiers) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RowIdentifiers.Merge(dst, src)
 }
 func (m *RowIdentifiers) XXX_Size() int {
 	return m.Size()
@@ -217,7 +216,7 @@ 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_413a91106d7bcce8, []int{3}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{3}
 }
 func (m *Pair) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -227,15 +226,15 @@ func (m *Pair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_Pair.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *Pair) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Pair.Merge(m, src)
+func (dst *Pair) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Pair.Merge(dst, src)
 }
 func (m *Pair) XXX_Size() int {
 	return m.Size()
@@ -268,7 +267,7 @@ func (m *Pair) GetCount() uint64 {
 }
 
 type PairField struct {
-	Pair                 *Pair    `protobuf:"bytes,1,opt,name=Pair,proto3" json:"Pair,omitempty"`
+	Pair                 *Pair    `protobuf:"bytes,1,opt,name=Pair" json:"Pair,omitempty"`
 	Field                string   `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
@@ -279,7 +278,7 @@ func (m *PairField) Reset()         { *m = PairField{} }
 func (m *PairField) String() string { return proto.CompactTextString(m) }
 func (*PairField) ProtoMessage()    {}
 func (*PairField) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{4}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{4}
 }
 func (m *PairField) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -289,15 +288,15 @@ func (m *PairField) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_PairField.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *PairField) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_PairField.Merge(m, src)
+func (dst *PairField) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_PairField.Merge(dst, src)
 }
 func (m *PairField) XXX_Size() int {
 	return m.Size()
@@ -323,7 +322,7 @@ func (m *PairField) GetField() string {
 }
 
 type PairsField struct {
-	Pairs                []*Pair  `protobuf:"bytes,1,rep,name=Pairs,proto3" json:"Pairs,omitempty"`
+	Pairs                []*Pair  `protobuf:"bytes,1,rep,name=Pairs" json:"Pairs,omitempty"`
 	Field                string   `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
@@ -334,7 +333,7 @@ func (m *PairsField) Reset()         { *m = PairsField{} }
 func (m *PairsField) String() string { return proto.CompactTextString(m) }
 func (*PairsField) ProtoMessage()    {}
 func (*PairsField) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{5}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{5}
 }
 func (m *PairsField) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -344,15 +343,15 @@ func (m *PairsField) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_PairsField.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *PairsField) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_PairsField.Merge(m, src)
+func (dst *PairsField) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_PairsField.Merge(dst, src)
 }
 func (m *PairsField) XXX_Size() int {
 	return m.Size()
@@ -390,7 +389,7 @@ func (m *FieldRow) Reset()         { *m = FieldRow{} }
 func (m *FieldRow) String() string { return proto.CompactTextString(m) }
 func (*FieldRow) ProtoMessage()    {}
 func (*FieldRow) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{6}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{6}
 }
 func (m *FieldRow) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -400,15 +399,15 @@ func (m *FieldRow) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_FieldRow.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *FieldRow) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FieldRow.Merge(m, src)
+func (dst *FieldRow) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FieldRow.Merge(dst, src)
 }
 func (m *FieldRow) XXX_Size() int {
 	return m.Size()
@@ -441,7 +440,7 @@ func (m *FieldRow) GetRowKey() string {
 }
 
 type GroupCount struct {
-	Group                []*FieldRow `protobuf:"bytes,1,rep,name=Group,proto3" json:"Group,omitempty"`
+	Group                []*FieldRow `protobuf:"bytes,1,rep,name=Group" json:"Group,omitempty"`
 	Count                uint64      `protobuf:"varint,2,opt,name=Count,proto3" json:"Count,omitempty"`
 	Sum                  int64       `protobuf:"varint,3,opt,name=Sum,proto3" json:"Sum,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
@@ -453,7 +452,7 @@ func (m *GroupCount) Reset()         { *m = GroupCount{} }
 func (m *GroupCount) String() string { return proto.CompactTextString(m) }
 func (*GroupCount) ProtoMessage()    {}
 func (*GroupCount) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{7}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{7}
 }
 func (m *GroupCount) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -463,15 +462,15 @@ func (m *GroupCount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_GroupCount.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *GroupCount) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GroupCount.Merge(m, src)
+func (dst *GroupCount) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GroupCount.Merge(dst, src)
 }
 func (m *GroupCount) XXX_Size() int {
 	return m.Size()
@@ -515,7 +514,7 @@ func (m *ValCount) Reset()         { *m = ValCount{} }
 func (m *ValCount) String() string { return proto.CompactTextString(m) }
 func (*ValCount) ProtoMessage()    {}
 func (*ValCount) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{8}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{8}
 }
 func (m *ValCount) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -525,15 +524,15 @@ func (m *ValCount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_ValCount.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *ValCount) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ValCount.Merge(m, src)
+func (dst *ValCount) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ValCount.Merge(dst, src)
 }
 func (m *ValCount) XXX_Size() int {
 	return m.Size()
@@ -561,7 +560,7 @@ 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,proto3" json:"Attrs,omitempty"`
+	Attrs                []*Attr  `protobuf:"bytes,2,rep,name=Attrs" json:"Attrs,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -571,7 +570,7 @@ func (m *ColumnAttrSet) Reset()         { *m = ColumnAttrSet{} }
 func (m *ColumnAttrSet) String() string { return proto.CompactTextString(m) }
 func (*ColumnAttrSet) ProtoMessage()    {}
 func (*ColumnAttrSet) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{9}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{9}
 }
 func (m *ColumnAttrSet) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -581,15 +580,15 @@ func (m *ColumnAttrSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
 		return xxx_messageInfo_ColumnAttrSet.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *ColumnAttrSet) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ColumnAttrSet.Merge(m, src)
+func (dst *ColumnAttrSet) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ColumnAttrSet.Merge(dst, src)
 }
 func (m *ColumnAttrSet) XXX_Size() int {
 	return m.Size()
@@ -637,7 +636,7 @@ func (m *Attr) Reset()         { *m = Attr{} }
 func (m *Attr) String() string { return proto.CompactTextString(m) }
 func (*Attr) ProtoMessage()    {}
 func (*Attr) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{10}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{10}
 }
 func (m *Attr) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -647,15 +646,15 @@ func (m *Attr) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_Attr.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *Attr) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Attr.Merge(m, src)
+func (dst *Attr) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Attr.Merge(dst, src)
 }
 func (m *Attr) XXX_Size() int {
 	return m.Size()
@@ -709,7 +708,7 @@ func (m *Attr) GetFloatValue() float64 {
 }
 
 type AttrMap struct {
-	Attrs                []*Attr  `protobuf:"bytes,1,rep,name=Attrs,proto3" 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:"-"`
@@ -719,7 +718,7 @@ func (m *AttrMap) Reset()         { *m = AttrMap{} }
 func (m *AttrMap) String() string { return proto.CompactTextString(m) }
 func (*AttrMap) ProtoMessage()    {}
 func (*AttrMap) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{11}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{11}
 }
 func (m *AttrMap) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -729,15 +728,15 @@ func (m *AttrMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_AttrMap.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *AttrMap) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_AttrMap.Merge(m, src)
+func (dst *AttrMap) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_AttrMap.Merge(dst, src)
 }
 func (m *AttrMap) XXX_Size() int {
 	return m.Size()
@@ -757,12 +756,12 @@ 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,proto3" json:"Shards,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"`
-	EmbeddedData         []*Row   `protobuf:"bytes,8,rep,name=EmbeddedData,proto3" json:"EmbeddedData,omitempty"`
+	EmbeddedData         []*Row   `protobuf:"bytes,8,rep,name=EmbeddedData" json:"EmbeddedData,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -772,7 +771,7 @@ func (m *QueryRequest) Reset()         { *m = QueryRequest{} }
 func (m *QueryRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryRequest) ProtoMessage()    {}
 func (*QueryRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{12}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{12}
 }
 func (m *QueryRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -782,15 +781,15 @@ func (m *QueryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return xxx_messageInfo_QueryRequest.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *QueryRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryRequest.Merge(m, src)
+func (dst *QueryRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryRequest.Merge(dst, src)
 }
 func (m *QueryRequest) XXX_Size() int {
 	return m.Size()
@@ -852,8 +851,8 @@ func (m *QueryRequest) GetEmbeddedData() []*Row {
 
 type QueryResponse struct {
 	Err                  string           `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
-	Results              []*QueryResult   `protobuf:"bytes,2,rep,name=Results,proto3" json:"Results,omitempty"`
-	ColumnAttrSets       []*ColumnAttrSet `protobuf:"bytes,3,rep,name=ColumnAttrSets,proto3" json:"ColumnAttrSets,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:"-"`
@@ -863,7 +862,7 @@ func (m *QueryResponse) Reset()         { *m = QueryResponse{} }
 func (m *QueryResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryResponse) ProtoMessage()    {}
 func (*QueryResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{13}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{13}
 }
 func (m *QueryResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -873,15 +872,15 @@ func (m *QueryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
 		return xxx_messageInfo_QueryResponse.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *QueryResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryResponse.Merge(m, src)
+func (dst *QueryResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryResponse.Merge(dst, src)
 }
 func (m *QueryResponse) XXX_Size() int {
 	return m.Size()
@@ -915,16 +914,16 @@ 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,proto3" json:"Row,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,proto3" json:"Pairs,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,proto3" json:"ValCount,omitempty"`
-	RowIDs               []uint64        `protobuf:"varint,7,rep,packed,name=RowIDs,proto3" json:"RowIDs,omitempty"`
-	GroupCounts          []*GroupCount   `protobuf:"bytes,8,rep,name=GroupCounts,proto3" json:"GroupCounts,omitempty"`
-	RowIdentifiers       *RowIdentifiers `protobuf:"bytes,9,opt,name=RowIdentifiers,proto3" json:"RowIdentifiers,omitempty"`
-	SignedRow            *SignedRow      `protobuf:"bytes,10,opt,name=SignedRow,proto3" json:"SignedRow,omitempty"`
-	PairsField           *PairsField     `protobuf:"bytes,11,opt,name=PairsField,proto3" json:"PairsField,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"`
+	SignedRow            *SignedRow      `protobuf:"bytes,10,opt,name=SignedRow" json:"SignedRow,omitempty"`
+	PairsField           *PairsField     `protobuf:"bytes,11,opt,name=PairsField" json:"PairsField,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
 	XXX_unrecognized     []byte          `json:"-"`
 	XXX_sizecache        int32           `json:"-"`
@@ -934,7 +933,7 @@ func (m *QueryResult) Reset()         { *m = QueryResult{} }
 func (m *QueryResult) String() string { return proto.CompactTextString(m) }
 func (*QueryResult) ProtoMessage()    {}
 func (*QueryResult) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{14}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{14}
 }
 func (m *QueryResult) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -944,15 +943,15 @@ func (m *QueryResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return xxx_messageInfo_QueryResult.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *QueryResult) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryResult.Merge(m, src)
+func (dst *QueryResult) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryResult.Merge(dst, src)
 }
 func (m *QueryResult) XXX_Size() int {
 	return m.Size()
@@ -1044,11 +1043,11 @@ 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,proto3" json:"RowIDs,omitempty"`
-	ColumnIDs            []uint64 `protobuf:"varint,5,rep,packed,name=ColumnIDs,proto3" json:"ColumnIDs,omitempty"`
-	RowKeys              []string `protobuf:"bytes,7,rep,name=RowKeys,proto3" json:"RowKeys,omitempty"`
-	ColumnKeys           []string `protobuf:"bytes,8,rep,name=ColumnKeys,proto3" json:"ColumnKeys,omitempty"`
-	Timestamps           []int64  `protobuf:"varint,6,rep,packed,name=Timestamps,proto3" json:"Timestamps,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:"-"`
@@ -1058,7 +1057,7 @@ func (m *ImportRequest) Reset()         { *m = ImportRequest{} }
 func (m *ImportRequest) String() string { return proto.CompactTextString(m) }
 func (*ImportRequest) ProtoMessage()    {}
 func (*ImportRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{15}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{15}
 }
 func (m *ImportRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1068,15 +1067,15 @@ func (m *ImportRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
 		return xxx_messageInfo_ImportRequest.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *ImportRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ImportRequest.Merge(m, src)
+func (dst *ImportRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ImportRequest.Merge(dst, src)
 }
 func (m *ImportRequest) XXX_Size() int {
 	return m.Size()
@@ -1147,10 +1146,11 @@ 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,proto3" json:"ColumnIDs,omitempty"`
-	ColumnKeys           []string  `protobuf:"bytes,7,rep,name=ColumnKeys,proto3" json:"ColumnKeys,omitempty"`
-	Values               []int64   `protobuf:"varint,6,rep,packed,name=Values,proto3" json:"Values,omitempty"`
-	FloatValues          []float64 `protobuf:"fixed64,8,rep,packed,name=FloatValues,proto3" json:"FloatValues,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"`
+	StringValues         []string  `protobuf:"bytes,9,rep,name=StringValues" json:"StringValues,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
 	XXX_unrecognized     []byte    `json:"-"`
 	XXX_sizecache        int32     `json:"-"`
@@ -1160,7 +1160,7 @@ func (m *ImportValueRequest) Reset()         { *m = ImportValueRequest{} }
 func (m *ImportValueRequest) String() string { return proto.CompactTextString(m) }
 func (*ImportValueRequest) ProtoMessage()    {}
 func (*ImportValueRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{16}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{16}
 }
 func (m *ImportValueRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1170,15 +1170,15 @@ func (m *ImportValueRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return xxx_messageInfo_ImportValueRequest.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *ImportValueRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ImportValueRequest.Merge(m, src)
+func (dst *ImportValueRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ImportValueRequest.Merge(dst, src)
 }
 func (m *ImportValueRequest) XXX_Size() int {
 	return m.Size()
@@ -1238,10 +1238,17 @@ func (m *ImportValueRequest) GetFloatValues() []float64 {
 	return nil
 }
 
+func (m *ImportValueRequest) GetStringValues() []string {
+	if m != nil {
+		return m.StringValues
+	}
+	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,proto3" json:"Keys,omitempty"`
+	Keys                 []string `protobuf:"bytes,3,rep,name=Keys" json:"Keys,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1251,7 +1258,7 @@ func (m *TranslateKeysRequest) Reset()         { *m = TranslateKeysRequest{} }
 func (m *TranslateKeysRequest) String() string { return proto.CompactTextString(m) }
 func (*TranslateKeysRequest) ProtoMessage()    {}
 func (*TranslateKeysRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{17}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{17}
 }
 func (m *TranslateKeysRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1261,15 +1268,15 @@ func (m *TranslateKeysRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte
 		return xxx_messageInfo_TranslateKeysRequest.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *TranslateKeysRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_TranslateKeysRequest.Merge(m, src)
+func (dst *TranslateKeysRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TranslateKeysRequest.Merge(dst, src)
 }
 func (m *TranslateKeysRequest) XXX_Size() int {
 	return m.Size()
@@ -1302,7 +1309,7 @@ func (m *TranslateKeysRequest) GetKeys() []string {
 }
 
 type TranslateKeysResponse struct {
-	IDs                  []uint64 `protobuf:"varint,3,rep,packed,name=IDs,proto3" 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:"-"`
@@ -1312,7 +1319,7 @@ func (m *TranslateKeysResponse) Reset()         { *m = TranslateKeysResponse{} }
 func (m *TranslateKeysResponse) String() string { return proto.CompactTextString(m) }
 func (*TranslateKeysResponse) ProtoMessage()    {}
 func (*TranslateKeysResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{18}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{18}
 }
 func (m *TranslateKeysResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1322,15 +1329,15 @@ func (m *TranslateKeysResponse) XXX_Marshal(b []byte, deterministic bool) ([]byt
 		return xxx_messageInfo_TranslateKeysResponse.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *TranslateKeysResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_TranslateKeysResponse.Merge(m, src)
+func (dst *TranslateKeysResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TranslateKeysResponse.Merge(dst, src)
 }
 func (m *TranslateKeysResponse) XXX_Size() int {
 	return m.Size()
@@ -1351,7 +1358,7 @@ func (m *TranslateKeysResponse) GetIDs() []uint64 {
 type TranslateIDsRequest 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"`
-	IDs                  []uint64 `protobuf:"varint,3,rep,packed,name=IDs,proto3" 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:"-"`
@@ -1361,7 +1368,7 @@ func (m *TranslateIDsRequest) Reset()         { *m = TranslateIDsRequest{} }
 func (m *TranslateIDsRequest) String() string { return proto.CompactTextString(m) }
 func (*TranslateIDsRequest) ProtoMessage()    {}
 func (*TranslateIDsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{19}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{19}
 }
 func (m *TranslateIDsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1371,15 +1378,15 @@ func (m *TranslateIDsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return xxx_messageInfo_TranslateIDsRequest.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *TranslateIDsRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_TranslateIDsRequest.Merge(m, src)
+func (dst *TranslateIDsRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TranslateIDsRequest.Merge(dst, src)
 }
 func (m *TranslateIDsRequest) XXX_Size() int {
 	return m.Size()
@@ -1412,7 +1419,7 @@ func (m *TranslateIDsRequest) GetIDs() []uint64 {
 }
 
 type TranslateIDsResponse struct {
-	Keys                 []string `protobuf:"bytes,3,rep,name=Keys,proto3" json:"Keys,omitempty"`
+	Keys                 []string `protobuf:"bytes,3,rep,name=Keys" json:"Keys,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1422,7 +1429,7 @@ func (m *TranslateIDsResponse) Reset()         { *m = TranslateIDsResponse{} }
 func (m *TranslateIDsResponse) String() string { return proto.CompactTextString(m) }
 func (*TranslateIDsResponse) ProtoMessage()    {}
 func (*TranslateIDsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{20}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{20}
 }
 func (m *TranslateIDsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1432,15 +1439,15 @@ func (m *TranslateIDsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte
 		return xxx_messageInfo_TranslateIDsResponse.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *TranslateIDsResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_TranslateIDsResponse.Merge(m, src)
+func (dst *TranslateIDsResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TranslateIDsResponse.Merge(dst, src)
 }
 func (m *TranslateIDsResponse) XXX_Size() int {
 	return m.Size()
@@ -1470,7 +1477,7 @@ func (m *ImportRoaringRequestView) Reset()         { *m = ImportRoaringRequestVi
 func (m *ImportRoaringRequestView) String() string { return proto.CompactTextString(m) }
 func (*ImportRoaringRequestView) ProtoMessage()    {}
 func (*ImportRoaringRequestView) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{21}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{21}
 }
 func (m *ImportRoaringRequestView) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1480,15 +1487,15 @@ func (m *ImportRoaringRequestView) XXX_Marshal(b []byte, deterministic bool) ([]
 		return xxx_messageInfo_ImportRoaringRequestView.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *ImportRoaringRequestView) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ImportRoaringRequestView.Merge(m, src)
+func (dst *ImportRoaringRequestView) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ImportRoaringRequestView.Merge(dst, src)
 }
 func (m *ImportRoaringRequestView) XXX_Size() int {
 	return m.Size()
@@ -1515,7 +1522,7 @@ 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,proto3" json:"views,omitempty"`
+	Views                []*ImportRoaringRequestView `protobuf:"bytes,2,rep,name=views" json:"views,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
 	XXX_unrecognized     []byte                      `json:"-"`
 	XXX_sizecache        int32                       `json:"-"`
@@ -1525,7 +1532,7 @@ func (m *ImportRoaringRequest) Reset()         { *m = ImportRoaringRequest{} }
 func (m *ImportRoaringRequest) String() string { return proto.CompactTextString(m) }
 func (*ImportRoaringRequest) ProtoMessage()    {}
 func (*ImportRoaringRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{22}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{22}
 }
 func (m *ImportRoaringRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1535,15 +1542,15 @@ func (m *ImportRoaringRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte
 		return xxx_messageInfo_ImportRoaringRequest.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *ImportRoaringRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ImportRoaringRequest.Merge(m, src)
+func (dst *ImportRoaringRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ImportRoaringRequest.Merge(dst, src)
 }
 func (m *ImportRoaringRequest) XXX_Size() int {
 	return m.Size()
@@ -1572,8 +1579,8 @@ type ImportColumnAttrsRequest struct {
 	Index                string   `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
 	Shard                int64    `protobuf:"varint,2,opt,name=Shard,proto3" json:"Shard,omitempty"`
 	AttrKey              string   `protobuf:"bytes,3,opt,name=AttrKey,proto3" json:"AttrKey,omitempty"`
-	AttrVals             []string `protobuf:"bytes,4,rep,name=AttrVals,proto3" json:"AttrVals,omitempty"`
-	ColumnIDs            []uint64 `protobuf:"varint,5,rep,packed,name=ColumnIDs,proto3" json:"ColumnIDs,omitempty"`
+	AttrVals             []string `protobuf:"bytes,4,rep,name=AttrVals" json:"AttrVals,omitempty"`
+	ColumnIDs            []uint64 `protobuf:"varint,5,rep,packed,name=ColumnIDs" json:"ColumnIDs,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1583,7 +1590,7 @@ func (m *ImportColumnAttrsRequest) Reset()         { *m = ImportColumnAttrsReque
 func (m *ImportColumnAttrsRequest) String() string { return proto.CompactTextString(m) }
 func (*ImportColumnAttrsRequest) ProtoMessage()    {}
 func (*ImportColumnAttrsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_413a91106d7bcce8, []int{23}
+	return fileDescriptor_public_34478dbd0ceb9d33, []int{23}
 }
 func (m *ImportColumnAttrsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1593,15 +1600,15 @@ func (m *ImportColumnAttrsRequest) XXX_Marshal(b []byte, deterministic bool) ([]
 		return xxx_messageInfo_ImportColumnAttrsRequest.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (m *ImportColumnAttrsRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ImportColumnAttrsRequest.Merge(m, src)
+func (dst *ImportColumnAttrsRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ImportColumnAttrsRequest.Merge(dst, src)
 }
 func (m *ImportColumnAttrsRequest) XXX_Size() int {
 	return m.Size()
@@ -1673,85 +1680,10 @@ func init() {
 	proto.RegisterType((*ImportRoaringRequest)(nil), "internal.ImportRoaringRequest")
 	proto.RegisterType((*ImportColumnAttrsRequest)(nil), "internal.ImportColumnAttrsRequest")
 }
-
-func init() { proto.RegisterFile("public.proto", fileDescriptor_413a91106d7bcce8) }
-
-var fileDescriptor_413a91106d7bcce8 = []byte{
-	// 1084 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcd, 0x8e, 0x1b, 0x45,
-	0x10, 0xa6, 0x3d, 0xe3, 0xf5, 0xb8, 0xbc, 0xbb, 0x44, 0x1d, 0x27, 0x8c, 0x50, 0xb4, 0xb1, 0x5a,
-	0x11, 0x1a, 0x38, 0x6c, 0x94, 0x05, 0xa1, 0x9c, 0xf8, 0x49, 0xec, 0x80, 0x15, 0xc5, 0x0a, 0xed,
-	0x95, 0xb9, 0x21, 0xcd, 0x66, 0x3a, 0xce, 0x48, 0xe3, 0x19, 0x33, 0x3f, 0x38, 0xfb, 0x1c, 0x5c,
-	0x10, 0x4f, 0xc0, 0x3b, 0xf0, 0x02, 0x9c, 0x10, 0x8f, 0x00, 0xcb, 0x63, 0x70, 0x41, 0x55, 0x3d,
-	0xed, 0x1e, 0x7b, 0xbd, 0x4b, 0x14, 0x71, 0xab, 0xbf, 0xae, 0xae, 0xaf, 0xba, 0xfa, 0xeb, 0x86,
-	0xfd, 0x65, 0x75, 0x96, 0xc4, 0x2f, 0x8e, 0x97, 0x79, 0x56, 0x66, 0xdc, 0x8b, 0xd3, 0x52, 0xe5,
-	0x69, 0x98, 0x88, 0x02, 0x1c, 0x99, 0xad, 0xb8, 0x0f, 0x9d, 0xc7, 0x59, 0x52, 0x2d, 0xd2, 0xc2,
-	0x67, 0x03, 0x27, 0x70, 0xa5, 0x51, 0x39, 0x07, 0xf7, 0xa9, 0x3a, 0x2f, 0x7c, 0x67, 0xe0, 0x04,
-	0x5d, 0x49, 0x32, 0xbf, 0x07, 0xed, 0x2f, 0xcb, 0x32, 0x2f, 0xfc, 0xd6, 0xc0, 0x09, 0x7a, 0x27,
-	0x87, 0xc7, 0x26, 0xdd, 0x31, 0x9a, 0xa5, 0x76, 0x62, 0x4e, 0x99, 0x85, 0x79, 0x9c, 0xce, 0x7d,
-	0x77, 0xc0, 0x82, 0x7d, 0x69, 0x54, 0xf1, 0x0c, 0xba, 0xd3, 0x78, 0x9e, 0xaa, 0x08, 0xb7, 0xbe,
-	0x0b, 0xce, 0xf3, 0x0c, 0xb7, 0x65, 0x41, 0xef, 0xe4, 0xc0, 0xa6, 0x92, 0xd9, 0x4a, 0xa2, 0x07,
-	0x03, 0x26, 0x6a, 0xee, 0xb7, 0x76, 0x06, 0x4c, 0xd4, 0x5c, 0x3c, 0x84, 0x43, 0x99, 0xad, 0xc6,
-	0x91, 0x4a, 0xcb, 0xf8, 0x65, 0xac, 0x72, 0x2a, 0x5a, 0x66, 0x2b, 0x83, 0x85, 0xe4, 0x35, 0x90,
-	0x96, 0x05, 0x22, 0x3e, 0x03, 0xf7, 0x79, 0x18, 0xe7, 0xfc, 0x10, 0x5a, 0xe3, 0x21, 0x95, 0xe0,
-	0xca, 0xd6, 0x78, 0xc8, 0x6f, 0x80, 0xf3, 0x54, 0x9d, 0xfb, 0xce, 0x80, 0x05, 0x5d, 0x89, 0x22,
-	0xef, 0x43, 0xfb, 0x71, 0x56, 0xa5, 0x25, 0x95, 0xe1, 0x4a, 0xad, 0x88, 0x11, 0x74, 0x71, 0xfd,
-	0x93, 0x58, 0x25, 0x11, 0x17, 0x3a, 0x59, 0x8d, 0xa4, 0xd1, 0x14, 0xb4, 0x4a, 0xbd, 0x51, 0x1f,
-	0xda, 0x14, 0x4c, 0x69, 0xba, 0x52, 0x2b, 0xe2, 0x6b, 0x00, 0xf4, 0x16, 0x3a, 0xcf, 0x3d, 0x68,
-	0x93, 0x46, 0xd5, 0x5f, 0x4e, 0xa4, 0x9d, 0x57, 0x64, 0x9a, 0x80, 0x47, 0x02, 0x36, 0x76, 0x1d,
-	0xc1, 0x1a, 0x11, 0x68, 0xc5, 0x66, 0x0d, 0x0d, 0x10, 0x52, 0xf8, 0x6d, 0xd8, 0x93, 0xd9, 0xca,
-	0x62, 0xae, 0x35, 0xf1, 0x1d, 0xc0, 0x57, 0x79, 0x56, 0x2d, 0x09, 0x2e, 0x0f, 0xa0, 0x4d, 0x5a,
-	0x5d, 0x19, 0xb7, 0x95, 0x99, 0x4d, 0xa5, 0x0e, 0xd8, 0xdd, 0x2e, 0x6c, 0xeb, 0xb4, 0x5a, 0xd0,
-	0x16, 0x8e, 0x44, 0x51, 0x9c, 0x80, 0x37, 0x0b, 0x93, 0xb5, 0x77, 0x16, 0x26, 0x54, 0xad, 0x23,
-	0x51, 0xdc, 0xcc, 0xe2, 0x98, 0xa6, 0x7f, 0x0b, 0x07, 0x7a, 0x38, 0x71, 0xcc, 0xa6, 0xaa, 0x7c,
-	0x83, 0xd3, 0x7b, 0xa3, 0x81, 0x15, 0xbf, 0x30, 0x70, 0x51, 0x32, 0x09, 0x98, 0x4d, 0xc0, 0xc1,
-	0x3d, 0x3d, 0x5f, 0xaa, 0x1a, 0x0e, 0xc9, 0x7c, 0x00, 0xbd, 0x69, 0x89, 0xf3, 0x3c, 0x0b, 0x93,
-	0x4a, 0xd5, 0xdb, 0x35, 0x4d, 0xfc, 0x7d, 0xf0, 0xc6, 0x69, 0xa9, 0xdd, 0x2e, 0x41, 0x58, 0xeb,
-	0xfc, 0x0e, 0x74, 0x1f, 0x65, 0x59, 0xa2, 0x9d, 0xed, 0x01, 0x0b, 0x3c, 0x69, 0x0d, 0xfc, 0x08,
-	0xe0, 0x49, 0x92, 0x85, 0xf5, 0xda, 0xbd, 0x01, 0x0b, 0x98, 0x6c, 0x58, 0xc4, 0x7d, 0xe8, 0x60,
-	0xa5, 0xcf, 0xc2, 0xa5, 0xc5, 0xc6, 0xae, 0xc3, 0xf6, 0x0f, 0x83, 0xfd, 0x6f, 0x2a, 0x95, 0x9f,
-	0x4b, 0xf5, 0x7d, 0xa5, 0x8a, 0x12, 0x7b, 0x4b, 0xba, 0x99, 0x0e, 0x52, 0x70, 0x0e, 0xa6, 0xaf,
-	0xc2, 0x3c, 0xd2, 0x9d, 0x72, 0x65, 0xad, 0x21, 0x56, 0xdb, 0xf3, 0x82, 0xb0, 0x7a, 0xb2, 0x69,
-	0xa2, 0x09, 0x52, 0x8b, 0xac, 0x34, 0x60, 0x6a, 0x8d, 0x07, 0xf0, 0xee, 0xe8, 0xf5, 0x8b, 0xa4,
-	0x8a, 0x94, 0xcc, 0x56, 0x7a, 0xf5, 0x1e, 0x05, 0x6c, 0x9b, 0xf9, 0x07, 0x70, 0x58, 0x9b, 0x0c,
-	0x15, 0x75, 0x28, 0x70, 0xcb, 0xca, 0x1f, 0xc0, 0xfe, 0x68, 0x71, 0xa6, 0xa2, 0x48, 0x45, 0xc3,
-	0xb0, 0x0c, 0x7d, 0x8f, 0x70, 0x6f, 0x11, 0xc3, 0x46, 0x88, 0xf8, 0x91, 0xc1, 0x41, 0x8d, 0xbe,
-	0x58, 0x66, 0x69, 0xa1, 0xf0, 0x88, 0x47, 0x79, 0x6e, 0x8e, 0x78, 0x94, 0xe7, 0xfc, 0x3e, 0x74,
-	0xa4, 0x2a, 0xaa, 0xa4, 0x34, 0x53, 0x72, 0xcb, 0x66, 0x34, 0x6b, 0xab, 0xa4, 0x94, 0x26, 0x8a,
-	0x7f, 0x0e, 0x87, 0x1b, 0x73, 0xa8, 0x39, 0xb2, 0x77, 0xf2, 0x9e, 0x5d, 0xb7, 0xe1, 0x97, 0x5b,
-	0xe1, 0xe2, 0x57, 0x07, 0x7a, 0x8d, 0xcc, 0xeb, 0x21, 0xc3, 0xfe, 0x1c, 0xd4, 0x43, 0x76, 0x97,
-	0xf8, 0xf9, 0x0a, 0x76, 0xc4, 0x5b, 0xbe, 0x0f, 0x6c, 0x52, 0x8f, 0x25, 0x9b, 0x58, 0xee, 0x70,
-	0xae, 0xe3, 0x0e, 0x64, 0xfb, 0x57, 0x61, 0x3a, 0x57, 0x11, 0x8d, 0xa5, 0x27, 0x8d, 0xca, 0x8f,
-	0xed, 0x7d, 0xa4, 0x73, 0xdc, 0xb8, 0xe4, 0xc6, 0x23, 0xed, 0x9d, 0xd5, 0xbc, 0x31, 0x1e, 0xe2,
-	0x59, 0xd1, 0xbc, 0x68, 0x8d, 0x7f, 0x0a, 0x3d, 0xcb, 0x1b, 0x45, 0x7d, 0x44, 0x7d, 0x9b, 0xca,
-	0x3a, 0x65, 0x33, 0x90, 0x7f, 0xb1, 0x4d, 0xe5, 0x7e, 0x97, 0xaa, 0xf0, 0x37, 0x90, 0x37, 0xfc,
-	0x72, 0x9b, 0xfa, 0x1f, 0x34, 0xde, 0x16, 0x1f, 0x68, 0xf1, 0x4d, 0xbb, 0x78, 0xed, 0x92, 0x8d,
-	0x17, 0xe8, 0x93, 0x26, 0xfd, 0xfa, 0x3d, 0x5a, 0xd3, 0xdf, 0xec, 0x9c, 0xf6, 0xc9, 0x46, 0x9c,
-	0xf8, 0x8b, 0xc1, 0xc1, 0x78, 0xb1, 0xcc, 0xf2, 0xb2, 0x71, 0xa5, 0xc6, 0x69, 0xa4, 0x5e, 0x9b,
-	0x2b, 0x45, 0xca, 0x6e, 0xa2, 0x46, 0x2b, 0x5d, 0x2d, 0xba, 0x4a, 0xae, 0xd4, 0x4a, 0xa3, 0x9d,
-	0xee, 0x46, 0x3b, 0xef, 0x40, 0x57, 0xcf, 0x0e, 0xba, 0xda, 0xe4, 0xb2, 0x06, 0xfd, 0xd0, 0xae,
-	0xe8, 0x71, 0xeb, 0xd0, 0xe3, 0x66, 0x54, 0xa4, 0x11, 0x1d, 0x46, 0x4e, 0x8f, 0x9c, 0x0d, 0x0b,
-	0xfa, 0x4f, 0xe3, 0x85, 0x2a, 0xca, 0x70, 0xb1, 0xc4, 0x7b, 0xe9, 0x04, 0x8e, 0x6c, 0x58, 0xc4,
-	0xef, 0x0c, 0xb8, 0xc6, 0x48, 0xb4, 0xf3, 0xff, 0x01, 0xbd, 0x1e, 0xd0, 0x66, 0xd9, 0x9d, 0x4b,
-	0x65, 0xdf, 0x86, 0x3d, 0xaa, 0xc7, 0x94, 0x5c, 0x6b, 0xc8, 0x52, 0x96, 0x23, 0x35, 0x5e, 0x26,
-	0x9b, 0x26, 0x31, 0x83, 0xfe, 0x69, 0x1e, 0xa6, 0x45, 0x12, 0x96, 0x0a, 0x53, 0xbd, 0x0d, 0xa2,
-	0x1d, 0x3f, 0x22, 0xf1, 0x21, 0xdc, 0xda, 0xca, 0x6b, 0x79, 0x06, 0x21, 0x3a, 0x04, 0x11, 0x45,
-	0x31, 0x85, 0x9b, 0xeb, 0xd0, 0xf1, 0xf0, 0xad, 0x2a, 0xb8, 0x9c, 0xf4, 0xa3, 0x06, 0x2e, 0x4a,
-	0x5a, 0x6f, 0xbf, 0xab, 0xd6, 0x47, 0xe0, 0xd7, 0x73, 0xab, 0xbf, 0x63, 0x75, 0x05, 0xb3, 0x58,
-	0xad, 0x30, 0x7e, 0x12, 0x2e, 0x54, 0x5d, 0x04, 0xc9, 0x68, 0x23, 0x9e, 0x6d, 0xd1, 0x27, 0x8e,
-	0x64, 0xf1, 0x12, 0xfa, 0xbb, 0x72, 0xd0, 0x8b, 0x9d, 0xa8, 0x50, 0x13, 0xab, 0x27, 0xb5, 0xc2,
-	0x1f, 0x42, 0xfb, 0x87, 0x58, 0xad, 0x0c, 0xb1, 0x0a, 0x7b, 0xb7, 0xae, 0x2a, 0x44, 0xea, 0x05,
-	0xe2, 0x67, 0x66, 0x8a, 0x6d, 0xbc, 0x35, 0xff, 0xd9, 0x32, 0x3d, 0x70, 0xf5, 0xa7, 0x41, 0x0f,
-	0x9c, 0xaf, 0x1f, 0x4c, 0xfb, 0x2f, 0x30, 0x2a, 0x3e, 0xd2, 0x28, 0xce, 0xc2, 0x44, 0xdf, 0xba,
-	0xae, 0x5c, 0xeb, 0xd7, 0x8f, 0xe9, 0xa3, 0x1b, 0xbf, 0x5d, 0x1c, 0xb1, 0x3f, 0x2e, 0x8e, 0xd8,
-	0x9f, 0x17, 0x47, 0xec, 0xa7, 0xbf, 0x8f, 0xde, 0x39, 0xdb, 0xa3, 0xef, 0xf5, 0xc7, 0xff, 0x06,
-	0x00, 0x00, 0xff, 0xff, 0x1a, 0x84, 0x0d, 0x7c, 0x6e, 0x0b, 0x00, 0x00,
-}
-
 func (m *Row) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -1759,49 +1691,10 @@ func (m *Row) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *Row) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Row) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if len(m.Roaring) > 0 {
-		i -= len(m.Roaring)
-		copy(dAtA[i:], m.Roaring)
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Roaring)))
-		i--
-		dAtA[i] = 0x22
-	}
-	if len(m.Keys) > 0 {
-		for iNdEx := len(m.Keys) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.Keys[iNdEx])
-			copy(dAtA[i:], m.Keys[iNdEx])
-			i = encodeVarintPublic(dAtA, i, uint64(len(m.Keys[iNdEx])))
-			i--
-			dAtA[i] = 0x1a
-		}
-	}
-	if len(m.Attrs) > 0 {
-		for iNdEx := len(m.Attrs) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Attrs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintPublic(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x12
-		}
-	}
 	if len(m.Columns) > 0 {
 		dAtA2 := make([]byte, len(m.Columns)*10)
 		var j1 int
@@ -1814,19 +1707,54 @@ func (m *Row) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			dAtA2[j1] = uint8(num)
 			j1++
 		}
-		i -= j1
-		copy(dAtA[i:], dAtA2[:j1])
-		i = encodeVarintPublic(dAtA, i, uint64(j1))
-		i--
 		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(j1))
+		i += copy(dAtA[i:], dAtA2[:j1])
 	}
-	return len(dAtA) - i, nil
+	if len(m.Attrs) > 0 {
+		for _, msg := range m.Attrs {
+			dAtA[i] = 0x12
+			i++
+			i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	if len(m.Keys) > 0 {
+		for _, s := range m.Keys {
+			dAtA[i] = 0x1a
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
+		}
+	}
+	if len(m.Roaring) > 0 {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Roaring)))
+		i += copy(dAtA[i:], m.Roaring)
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *SignedRow) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -1834,50 +1762,40 @@ func (m *SignedRow) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *SignedRow) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *SignedRow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
+	if m.Pos != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(m.Pos.Size()))
+		n3, err := m.Pos.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n3
 	}
 	if m.Neg != nil {
-		{
-			size, err := m.Neg.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintPublic(dAtA, i, uint64(size))
-		}
-		i--
 		dAtA[i] = 0x12
-	}
-	if m.Pos != nil {
-		{
-			size, err := m.Pos.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintPublic(dAtA, i, uint64(size))
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(m.Neg.Size()))
+		n4, err := m.Neg.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
 		}
-		i--
-		dAtA[i] = 0xa
+		i += n4
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *RowIdentifiers) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -1885,28 +1803,10 @@ func (m *RowIdentifiers) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *RowIdentifiers) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *RowIdentifiers) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if len(m.Keys) > 0 {
-		for iNdEx := len(m.Keys) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.Keys[iNdEx])
-			copy(dAtA[i:], m.Keys[iNdEx])
-			i = encodeVarintPublic(dAtA, i, uint64(len(m.Keys[iNdEx])))
-			i--
-			dAtA[i] = 0x12
-		}
-	}
 	if len(m.Rows) > 0 {
 		dAtA6 := make([]byte, len(m.Rows)*10)
 		var j5 int
@@ -1919,19 +1819,36 @@ func (m *RowIdentifiers) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			dAtA6[j5] = uint8(num)
 			j5++
 		}
-		i -= j5
-		copy(dAtA[i:], dAtA6[:j5])
-		i = encodeVarintPublic(dAtA, i, uint64(j5))
-		i--
 		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(j5))
+		i += copy(dAtA[i:], dAtA6[:j5])
 	}
-	return len(dAtA) - i, nil
+	if len(m.Keys) > 0 {
+		for _, s := range m.Keys {
+			dAtA[i] = 0x12
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *Pair) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -1939,43 +1856,36 @@ func (m *Pair) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *Pair) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Pair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if len(m.Key) > 0 {
-		i -= len(m.Key)
-		copy(dAtA[i:], m.Key)
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Key)))
-		i--
-		dAtA[i] = 0x1a
+	if m.ID != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(m.ID))
 	}
 	if m.Count != 0 {
-		i = encodeVarintPublic(dAtA, i, uint64(m.Count))
-		i--
 		dAtA[i] = 0x10
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(m.Count))
 	}
-	if m.ID != 0 {
-		i = encodeVarintPublic(dAtA, i, uint64(m.ID))
-		i--
-		dAtA[i] = 0x8
+	if len(m.Key) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Key)))
+		i += copy(dAtA[i:], m.Key)
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *PairField) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -1983,45 +1893,36 @@ func (m *PairField) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *PairField) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *PairField) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
+	if m.Pair != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(m.Pair.Size()))
+		n7, err := m.Pair.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n7
 	}
 	if len(m.Field) > 0 {
-		i -= len(m.Field)
-		copy(dAtA[i:], m.Field)
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
-		i--
 		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
+		i += copy(dAtA[i:], m.Field)
 	}
-	if m.Pair != nil {
-		{
-			size, err := m.Pair.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintPublic(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0xa
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *PairsField) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2029,47 +1930,38 @@ func (m *PairsField) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *PairsField) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *PairsField) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if len(m.Field) > 0 {
-		i -= len(m.Field)
-		copy(dAtA[i:], m.Field)
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
-		i--
-		dAtA[i] = 0x12
-	}
 	if len(m.Pairs) > 0 {
-		for iNdEx := len(m.Pairs) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Pairs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintPublic(dAtA, i, uint64(size))
-			}
-			i--
+		for _, msg := range m.Pairs {
 			dAtA[i] = 0xa
+			i++
+			i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
 		}
 	}
-	return len(dAtA) - i, nil
+	if len(m.Field) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPublic(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
 }
 
 func (m *FieldRow) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2077,45 +1969,37 @@ func (m *FieldRow) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *FieldRow) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *FieldRow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if len(m.RowKey) > 0 {
-		i -= len(m.RowKey)
-		copy(dAtA[i:], m.RowKey)
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.RowKey)))
-		i--
-		dAtA[i] = 0x1a
+	if len(m.Field) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
+		i += copy(dAtA[i:], m.Field)
 	}
 	if m.RowID != 0 {
-		i = encodeVarintPublic(dAtA, i, uint64(m.RowID))
-		i--
 		dAtA[i] = 0x10
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(m.RowID))
 	}
-	if len(m.Field) > 0 {
-		i -= len(m.Field)
-		copy(dAtA[i:], m.Field)
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
-		i--
-		dAtA[i] = 0xa
+	if len(m.RowKey) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.RowKey)))
+		i += copy(dAtA[i:], m.RowKey)
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *GroupCount) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2123,50 +2007,42 @@ func (m *GroupCount) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *GroupCount) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *GroupCount) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if m.Sum != 0 {
-		i = encodeVarintPublic(dAtA, i, uint64(m.Sum))
-		i--
-		dAtA[i] = 0x18
-	}
-	if m.Count != 0 {
-		i = encodeVarintPublic(dAtA, i, uint64(m.Count))
-		i--
-		dAtA[i] = 0x10
-	}
 	if len(m.Group) > 0 {
-		for iNdEx := len(m.Group) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Group[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintPublic(dAtA, i, uint64(size))
-			}
-			i--
+		for _, msg := range m.Group {
 			dAtA[i] = 0xa
+			i++
+			i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
 		}
 	}
-	return len(dAtA) - i, nil
+	if m.Count != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(m.Count))
+	}
+	if m.Sum != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(m.Sum))
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *ValCount) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2174,36 +2050,30 @@ func (m *ValCount) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ValCount) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ValCount) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
+	if m.Val != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(m.Val))
 	}
 	if m.Count != 0 {
-		i = encodeVarintPublic(dAtA, i, uint64(m.Count))
-		i--
 		dAtA[i] = 0x10
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(m.Count))
 	}
-	if m.Val != 0 {
-		i = encodeVarintPublic(dAtA, i, uint64(m.Val))
-		i--
-		dAtA[i] = 0x8
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *ColumnAttrSet) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2211,52 +2081,43 @@ func (m *ColumnAttrSet) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ColumnAttrSet) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ColumnAttrSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if len(m.Key) > 0 {
-		i -= len(m.Key)
-		copy(dAtA[i:], m.Key)
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Key)))
-		i--
-		dAtA[i] = 0x1a
+	if m.ID != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(m.ID))
 	}
 	if len(m.Attrs) > 0 {
-		for iNdEx := len(m.Attrs) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Attrs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintPublic(dAtA, i, uint64(size))
-			}
-			i--
+		for _, msg := range m.Attrs {
 			dAtA[i] = 0x12
+			i++
+			i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
 		}
 	}
-	if m.ID != 0 {
-		i = encodeVarintPublic(dAtA, i, uint64(m.ID))
-		i--
-		dAtA[i] = 0x8
+	if len(m.Key) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Key)))
+		i += copy(dAtA[i:], m.Key)
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *Attr) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2264,66 +2125,58 @@ func (m *Attr) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *Attr) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Attr) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Key) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Key)))
+		i += copy(dAtA[i:], m.Key)
 	}
-	if m.FloatValue != 0 {
-		i -= 8
-		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.FloatValue))))
-		i--
-		dAtA[i] = 0x31
+	if m.Type != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(m.Type))
+	}
+	if len(m.StringValue) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.StringValue)))
+		i += copy(dAtA[i:], m.StringValue)
+	}
+	if m.IntValue != 0 {
+		dAtA[i] = 0x20
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(m.IntValue))
 	}
 	if m.BoolValue {
-		i--
+		dAtA[i] = 0x28
+		i++
 		if m.BoolValue {
 			dAtA[i] = 1
 		} else {
 			dAtA[i] = 0
 		}
-		i--
-		dAtA[i] = 0x28
+		i++
 	}
-	if m.IntValue != 0 {
-		i = encodeVarintPublic(dAtA, i, uint64(m.IntValue))
-		i--
-		dAtA[i] = 0x20
+	if m.FloatValue != 0 {
+		dAtA[i] = 0x31
+		i++
+		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.FloatValue))))
+		i += 8
 	}
-	if len(m.StringValue) > 0 {
-		i -= len(m.StringValue)
-		copy(dAtA[i:], m.StringValue)
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.StringValue)))
-		i--
-		dAtA[i] = 0x1a
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	if m.Type != 0 {
-		i = encodeVarintPublic(dAtA, i, uint64(m.Type))
-		i--
-		dAtA[i] = 0x10
-	}
-	if len(m.Key) > 0 {
-		i -= len(m.Key)
-		copy(dAtA[i:], m.Key)
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Key)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *AttrMap) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2331,40 +2184,32 @@ func (m *AttrMap) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *AttrMap) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *AttrMap) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if len(m.Attrs) > 0 {
-		for iNdEx := len(m.Attrs) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Attrs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintPublic(dAtA, i, uint64(size))
-			}
-			i--
+		for _, msg := range m.Attrs {
 			dAtA[i] = 0xa
+			i++
+			i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
 		}
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *QueryRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2372,72 +2217,15 @@ func (m *QueryRequest) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *QueryRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if len(m.EmbeddedData) > 0 {
-		for iNdEx := len(m.EmbeddedData) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.EmbeddedData[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintPublic(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x42
-		}
-	}
-	if m.ExcludeColumns {
-		i--
-		if m.ExcludeColumns {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i--
-		dAtA[i] = 0x38
-	}
-	if m.ExcludeRowAttrs {
-		i--
-		if m.ExcludeRowAttrs {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i--
-		dAtA[i] = 0x30
-	}
-	if m.Remote {
-		i--
-		if m.Remote {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i--
-		dAtA[i] = 0x28
-	}
-	if m.ColumnAttrs {
-		i--
-		if m.ColumnAttrs {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i--
-		dAtA[i] = 0x18
+	if len(m.Query) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Query)))
+		i += copy(dAtA[i:], m.Query)
 	}
 	if len(m.Shards) > 0 {
 		dAtA9 := make([]byte, len(m.Shards)*10)
@@ -2451,26 +2239,73 @@ func (m *QueryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			dAtA9[j8] = uint8(num)
 			j8++
 		}
-		i -= j8
-		copy(dAtA[i:], dAtA9[:j8])
-		i = encodeVarintPublic(dAtA, i, uint64(j8))
-		i--
 		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(j8))
+		i += copy(dAtA[i:], dAtA9[:j8])
 	}
-	if len(m.Query) > 0 {
-		i -= len(m.Query)
-		copy(dAtA[i:], m.Query)
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Query)))
-		i--
-		dAtA[i] = 0xa
+	if m.ColumnAttrs {
+		dAtA[i] = 0x18
+		i++
+		if m.ColumnAttrs {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
 	}
-	return len(dAtA) - i, nil
+	if m.Remote {
+		dAtA[i] = 0x28
+		i++
+		if m.Remote {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if m.ExcludeRowAttrs {
+		dAtA[i] = 0x30
+		i++
+		if m.ExcludeRowAttrs {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if m.ExcludeColumns {
+		dAtA[i] = 0x38
+		i++
+		if m.ExcludeColumns {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if len(m.EmbeddedData) > 0 {
+		for _, msg := range m.EmbeddedData {
+			dAtA[i] = 0x42
+			i++
+			i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *QueryResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2478,61 +2313,50 @@ func (m *QueryResponse) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *QueryResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if len(m.ColumnAttrSets) > 0 {
-		for iNdEx := len(m.ColumnAttrSets) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.ColumnAttrSets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintPublic(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x1a
-		}
+	if len(m.Err) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Err)))
+		i += copy(dAtA[i:], m.Err)
 	}
 	if len(m.Results) > 0 {
-		for iNdEx := len(m.Results) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Results[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintPublic(dAtA, i, uint64(size))
-			}
-			i--
+		for _, msg := range m.Results {
 			dAtA[i] = 0x12
+			i++
+			i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
 		}
 	}
-	if len(m.Err) > 0 {
-		i -= len(m.Err)
-		copy(dAtA[i:], m.Err)
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Err)))
-		i--
-		dAtA[i] = 0xa
+	if len(m.ColumnAttrSets) > 0 {
+		for _, msg := range m.ColumnAttrSets {
+			dAtA[i] = 0x1a
+			i++
+			i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *QueryResult) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2540,152 +2364,131 @@ func (m *QueryResult) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *QueryResult) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
+	if m.Row != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(m.Row.Size()))
+		n10, err := m.Row.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n10
 	}
-	if m.PairsField != nil {
-		{
-			size, err := m.PairsField.MarshalToSizedBuffer(dAtA[:i])
+	if m.N != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(m.N))
+	}
+	if len(m.Pairs) > 0 {
+		for _, msg := range m.Pairs {
+			dAtA[i] = 0x1a
+			i++
+			i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
 			if err != nil {
 				return 0, err
 			}
-			i -= size
-			i = encodeVarintPublic(dAtA, i, uint64(size))
+			i += n
 		}
-		i--
-		dAtA[i] = 0x5a
-	}
-	if m.SignedRow != nil {
-		{
-			size, err := m.SignedRow.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintPublic(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x52
-	}
-	if m.RowIdentifiers != nil {
-		{
-			size, err := m.RowIdentifiers.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintPublic(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x4a
-	}
-	if len(m.GroupCounts) > 0 {
-		for iNdEx := len(m.GroupCounts) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.GroupCounts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintPublic(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x42
-		}
-	}
-	if len(m.RowIDs) > 0 {
-		dAtA14 := make([]byte, len(m.RowIDs)*10)
-		var j13 int
-		for _, num := range m.RowIDs {
-			for num >= 1<<7 {
-				dAtA14[j13] = uint8(uint64(num)&0x7f | 0x80)
-				num >>= 7
-				j13++
-			}
-			dAtA14[j13] = uint8(num)
-			j13++
-		}
-		i -= j13
-		copy(dAtA[i:], dAtA14[:j13])
-		i = encodeVarintPublic(dAtA, i, uint64(j13))
-		i--
-		dAtA[i] = 0x3a
-	}
-	if m.Type != 0 {
-		i = encodeVarintPublic(dAtA, i, uint64(m.Type))
-		i--
-		dAtA[i] = 0x30
-	}
-	if m.ValCount != nil {
-		{
-			size, err := m.ValCount.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintPublic(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x2a
 	}
 	if m.Changed {
-		i--
+		dAtA[i] = 0x20
+		i++
 		if m.Changed {
 			dAtA[i] = 1
 		} else {
 			dAtA[i] = 0
 		}
-		i--
-		dAtA[i] = 0x20
+		i++
 	}
-	if len(m.Pairs) > 0 {
-		for iNdEx := len(m.Pairs) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Pairs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintPublic(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x1a
+	if m.ValCount != nil {
+		dAtA[i] = 0x2a
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(m.ValCount.Size()))
+		n11, err := m.ValCount.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
 		}
+		i += n11
 	}
-	if m.N != 0 {
-		i = encodeVarintPublic(dAtA, i, uint64(m.N))
-		i--
-		dAtA[i] = 0x10
+	if m.Type != 0 {
+		dAtA[i] = 0x30
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(m.Type))
 	}
-	if m.Row != nil {
-		{
-			size, err := m.Row.MarshalToSizedBuffer(dAtA[:i])
+	if len(m.RowIDs) > 0 {
+		dAtA13 := make([]byte, len(m.RowIDs)*10)
+		var j12 int
+		for _, num := range m.RowIDs {
+			for num >= 1<<7 {
+				dAtA13[j12] = uint8(uint64(num)&0x7f | 0x80)
+				num >>= 7
+				j12++
+			}
+			dAtA13[j12] = uint8(num)
+			j12++
+		}
+		dAtA[i] = 0x3a
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(j12))
+		i += copy(dAtA[i:], dAtA13[:j12])
+	}
+	if len(m.GroupCounts) > 0 {
+		for _, msg := range m.GroupCounts {
+			dAtA[i] = 0x42
+			i++
+			i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
 			if err != nil {
 				return 0, err
 			}
-			i -= size
-			i = encodeVarintPublic(dAtA, i, uint64(size))
+			i += n
 		}
-		i--
-		dAtA[i] = 0xa
 	}
-	return len(dAtA) - i, nil
+	if m.RowIdentifiers != nil {
+		dAtA[i] = 0x4a
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(m.RowIdentifiers.Size()))
+		n14, err := m.RowIdentifiers.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n14
+	}
+	if m.SignedRow != nil {
+		dAtA[i] = 0x52
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(m.SignedRow.Size()))
+		n15, err := m.SignedRow.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n15
+	}
+	if m.PairsField != nil {
+		dAtA[i] = 0x5a
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(m.PairsField.Size()))
+		n16, err := m.PairsField.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n16
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *ImportRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2693,42 +2496,31 @@ func (m *ImportRequest) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ImportRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ImportRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Index) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
+		i += copy(dAtA[i:], m.Index)
 	}
-	if len(m.ColumnKeys) > 0 {
-		for iNdEx := len(m.ColumnKeys) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.ColumnKeys[iNdEx])
-			copy(dAtA[i:], m.ColumnKeys[iNdEx])
-			i = encodeVarintPublic(dAtA, i, uint64(len(m.ColumnKeys[iNdEx])))
-			i--
-			dAtA[i] = 0x42
-		}
+	if len(m.Field) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
+		i += copy(dAtA[i:], m.Field)
 	}
-	if len(m.RowKeys) > 0 {
-		for iNdEx := len(m.RowKeys) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.RowKeys[iNdEx])
-			copy(dAtA[i:], m.RowKeys[iNdEx])
-			i = encodeVarintPublic(dAtA, i, uint64(len(m.RowKeys[iNdEx])))
-			i--
-			dAtA[i] = 0x3a
-		}
+	if m.Shard != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(m.Shard))
 	}
-	if len(m.Timestamps) > 0 {
-		dAtA18 := make([]byte, len(m.Timestamps)*10)
+	if len(m.RowIDs) > 0 {
+		dAtA18 := make([]byte, len(m.RowIDs)*10)
 		var j17 int
-		for _, num1 := range m.Timestamps {
-			num := uint64(num1)
+		for _, num := range m.RowIDs {
 			for num >= 1<<7 {
 				dAtA18[j17] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
@@ -2737,11 +2529,10 @@ func (m *ImportRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			dAtA18[j17] = uint8(num)
 			j17++
 		}
-		i -= j17
-		copy(dAtA[i:], dAtA18[:j17])
+		dAtA[i] = 0x22
+		i++
 		i = encodeVarintPublic(dAtA, i, uint64(j17))
-		i--
-		dAtA[i] = 0x32
+		i += copy(dAtA[i:], dAtA18[:j17])
 	}
 	if len(m.ColumnIDs) > 0 {
 		dAtA20 := make([]byte, len(m.ColumnIDs)*10)
@@ -2755,16 +2546,16 @@ func (m *ImportRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			dAtA20[j19] = uint8(num)
 			j19++
 		}
-		i -= j19
-		copy(dAtA[i:], dAtA20[:j19])
-		i = encodeVarintPublic(dAtA, i, uint64(j19))
-		i--
 		dAtA[i] = 0x2a
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(j19))
+		i += copy(dAtA[i:], dAtA20[:j19])
 	}
-	if len(m.RowIDs) > 0 {
-		dAtA22 := make([]byte, len(m.RowIDs)*10)
+	if len(m.Timestamps) > 0 {
+		dAtA22 := make([]byte, len(m.Timestamps)*10)
 		var j21 int
-		for _, num := range m.RowIDs {
+		for _, num1 := range m.Timestamps {
+			num := uint64(num1)
 			for num >= 1<<7 {
 				dAtA22[j21] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
@@ -2773,38 +2564,51 @@ func (m *ImportRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			dAtA22[j21] = uint8(num)
 			j21++
 		}
-		i -= j21
-		copy(dAtA[i:], dAtA22[:j21])
+		dAtA[i] = 0x32
+		i++
 		i = encodeVarintPublic(dAtA, i, uint64(j21))
-		i--
-		dAtA[i] = 0x22
+		i += copy(dAtA[i:], dAtA22[:j21])
 	}
-	if m.Shard != 0 {
-		i = encodeVarintPublic(dAtA, i, uint64(m.Shard))
-		i--
-		dAtA[i] = 0x18
+	if len(m.RowKeys) > 0 {
+		for _, s := range m.RowKeys {
+			dAtA[i] = 0x3a
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
+		}
 	}
-	if len(m.Field) > 0 {
-		i -= len(m.Field)
-		copy(dAtA[i:], m.Field)
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
-		i--
-		dAtA[i] = 0x12
+	if len(m.ColumnKeys) > 0 {
+		for _, s := range m.ColumnKeys {
+			dAtA[i] = 0x42
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
+		}
 	}
-	if len(m.Index) > 0 {
-		i -= len(m.Index)
-		copy(dAtA[i:], m.Index)
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
-		i--
-		dAtA[i] = 0xa
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *ImportValueRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2812,101 +2616,112 @@ func (m *ImportValueRequest) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ImportValueRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ImportValueRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Index) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
+		i += copy(dAtA[i:], m.Index)
 	}
-	if len(m.FloatValues) > 0 {
-		for iNdEx := len(m.FloatValues) - 1; iNdEx >= 0; iNdEx-- {
-			f23 := math.Float64bits(float64(m.FloatValues[iNdEx]))
-			i -= 8
-			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f23))
-		}
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.FloatValues)*8))
-		i--
-		dAtA[i] = 0x42
+	if len(m.Field) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
+		i += copy(dAtA[i:], m.Field)
 	}
-	if len(m.ColumnKeys) > 0 {
-		for iNdEx := len(m.ColumnKeys) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.ColumnKeys[iNdEx])
-			copy(dAtA[i:], m.ColumnKeys[iNdEx])
-			i = encodeVarintPublic(dAtA, i, uint64(len(m.ColumnKeys[iNdEx])))
-			i--
-			dAtA[i] = 0x3a
+	if m.Shard != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(m.Shard))
+	}
+	if len(m.ColumnIDs) > 0 {
+		dAtA24 := make([]byte, len(m.ColumnIDs)*10)
+		var j23 int
+		for _, num := range m.ColumnIDs {
+			for num >= 1<<7 {
+				dAtA24[j23] = uint8(uint64(num)&0x7f | 0x80)
+				num >>= 7
+				j23++
+			}
+			dAtA24[j23] = uint8(num)
+			j23++
 		}
+		dAtA[i] = 0x2a
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(j23))
+		i += copy(dAtA[i:], dAtA24[:j23])
 	}
 	if len(m.Values) > 0 {
-		dAtA25 := make([]byte, len(m.Values)*10)
-		var j24 int
+		dAtA26 := make([]byte, len(m.Values)*10)
+		var j25 int
 		for _, num1 := range m.Values {
 			num := uint64(num1)
 			for num >= 1<<7 {
-				dAtA25[j24] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA26[j25] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j24++
+				j25++
 			}
-			dAtA25[j24] = uint8(num)
-			j24++
+			dAtA26[j25] = uint8(num)
+			j25++
 		}
-		i -= j24
-		copy(dAtA[i:], dAtA25[:j24])
-		i = encodeVarintPublic(dAtA, i, uint64(j24))
-		i--
 		dAtA[i] = 0x32
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(j25))
+		i += copy(dAtA[i:], dAtA26[:j25])
 	}
-	if len(m.ColumnIDs) > 0 {
-		dAtA27 := make([]byte, len(m.ColumnIDs)*10)
-		var j26 int
-		for _, num := range m.ColumnIDs {
-			for num >= 1<<7 {
-				dAtA27[j26] = uint8(uint64(num)&0x7f | 0x80)
-				num >>= 7
-				j26++
+	if len(m.ColumnKeys) > 0 {
+		for _, s := range m.ColumnKeys {
+			dAtA[i] = 0x3a
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
 			}
-			dAtA27[j26] = uint8(num)
-			j26++
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
 		}
-		i -= j26
-		copy(dAtA[i:], dAtA27[:j26])
-		i = encodeVarintPublic(dAtA, i, uint64(j26))
-		i--
-		dAtA[i] = 0x2a
 	}
-	if m.Shard != 0 {
-		i = encodeVarintPublic(dAtA, i, uint64(m.Shard))
-		i--
-		dAtA[i] = 0x18
+	if len(m.FloatValues) > 0 {
+		dAtA[i] = 0x42
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.FloatValues)*8))
+		for _, num := range m.FloatValues {
+			f27 := math.Float64bits(float64(num))
+			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f27))
+			i += 8
+		}
 	}
-	if len(m.Field) > 0 {
-		i -= len(m.Field)
-		copy(dAtA[i:], m.Field)
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
-		i--
-		dAtA[i] = 0x12
+	if len(m.StringValues) > 0 {
+		for _, s := range m.StringValues {
+			dAtA[i] = 0x4a
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
+		}
 	}
-	if len(m.Index) > 0 {
-		i -= len(m.Index)
-		copy(dAtA[i:], m.Index)
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
-		i--
-		dAtA[i] = 0xa
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *TranslateKeysRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2914,49 +2729,47 @@ func (m *TranslateKeysRequest) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *TranslateKeysRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *TranslateKeysRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if len(m.Keys) > 0 {
-		for iNdEx := len(m.Keys) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.Keys[iNdEx])
-			copy(dAtA[i:], m.Keys[iNdEx])
-			i = encodeVarintPublic(dAtA, i, uint64(len(m.Keys[iNdEx])))
-			i--
-			dAtA[i] = 0x1a
-		}
+	if len(m.Index) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
+		i += copy(dAtA[i:], m.Index)
 	}
 	if len(m.Field) > 0 {
-		i -= len(m.Field)
-		copy(dAtA[i:], m.Field)
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
-		i--
 		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
+		i += copy(dAtA[i:], m.Field)
 	}
-	if len(m.Index) > 0 {
-		i -= len(m.Index)
-		copy(dAtA[i:], m.Index)
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
-		i--
-		dAtA[i] = 0xa
+	if len(m.Keys) > 0 {
+		for _, s := range m.Keys {
+			dAtA[i] = 0x1a
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
+		}
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *TranslateKeysResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2964,19 +2777,10 @@ func (m *TranslateKeysResponse) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *TranslateKeysResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *TranslateKeysResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if len(m.IDs) > 0 {
 		dAtA29 := make([]byte, len(m.IDs)*10)
 		var j28 int
@@ -2989,19 +2793,21 @@ func (m *TranslateKeysResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			dAtA29[j28] = uint8(num)
 			j28++
 		}
-		i -= j28
-		copy(dAtA[i:], dAtA29[:j28])
-		i = encodeVarintPublic(dAtA, i, uint64(j28))
-		i--
 		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(j28))
+		i += copy(dAtA[i:], dAtA29[:j28])
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *TranslateIDsRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3009,18 +2815,21 @@ func (m *TranslateIDsRequest) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *TranslateIDsRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *TranslateIDsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Index) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
+		i += copy(dAtA[i:], m.Index)
+	}
+	if len(m.Field) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
+		i += copy(dAtA[i:], m.Field)
 	}
 	if len(m.IDs) > 0 {
 		dAtA31 := make([]byte, len(m.IDs)*10)
@@ -3034,33 +2843,21 @@ func (m *TranslateIDsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			dAtA31[j30] = uint8(num)
 			j30++
 		}
-		i -= j30
-		copy(dAtA[i:], dAtA31[:j30])
-		i = encodeVarintPublic(dAtA, i, uint64(j30))
-		i--
 		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(j30))
+		i += copy(dAtA[i:], dAtA31[:j30])
 	}
-	if len(m.Field) > 0 {
-		i -= len(m.Field)
-		copy(dAtA[i:], m.Field)
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
-		i--
-		dAtA[i] = 0x12
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	if len(m.Index) > 0 {
-		i -= len(m.Index)
-		copy(dAtA[i:], m.Index)
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *TranslateIDsResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3068,35 +2865,35 @@ func (m *TranslateIDsResponse) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *TranslateIDsResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *TranslateIDsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if len(m.Keys) > 0 {
-		for iNdEx := len(m.Keys) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.Keys[iNdEx])
-			copy(dAtA[i:], m.Keys[iNdEx])
-			i = encodeVarintPublic(dAtA, i, uint64(len(m.Keys[iNdEx])))
-			i--
+		for _, s := range m.Keys {
 			dAtA[i] = 0x1a
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
 		}
 	}
-	return len(dAtA) - i, nil
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *ImportRoaringRequestView) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3104,40 +2901,32 @@ func (m *ImportRoaringRequestView) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ImportRoaringRequestView) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ImportRoaringRequestView) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Name) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
 	}
 	if len(m.Data) > 0 {
-		i -= len(m.Data)
-		copy(dAtA[i:], m.Data)
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Data)))
-		i--
 		dAtA[i] = 0x12
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Data)))
+		i += copy(dAtA[i:], m.Data)
 	}
-	if len(m.Name) > 0 {
-		i -= len(m.Name)
-		copy(dAtA[i:], m.Name)
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Name)))
-		i--
-		dAtA[i] = 0xa
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *ImportRoaringRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3145,50 +2934,42 @@ func (m *ImportRoaringRequest) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ImportRoaringRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ImportRoaringRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	if len(m.Views) > 0 {
-		for iNdEx := len(m.Views) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Views[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintPublic(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x12
-		}
-	}
 	if m.Clear {
-		i--
+		dAtA[i] = 0x8
+		i++
 		if m.Clear {
 			dAtA[i] = 1
 		} else {
 			dAtA[i] = 0
 		}
-		i--
-		dAtA[i] = 0x8
+		i++
 	}
-	return len(dAtA) - i, nil
+	if len(m.Views) > 0 {
+		for _, msg := range m.Views {
+			dAtA[i] = 0x12
+			i++
+			i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
 }
 
 func (m *ImportColumnAttrsRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3196,18 +2977,41 @@ func (m *ImportColumnAttrsRequest) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ImportColumnAttrsRequest) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ImportColumnAttrsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Index) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
+		i += copy(dAtA[i:], m.Index)
+	}
+	if m.Shard != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(m.Shard))
+	}
+	if len(m.AttrKey) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.AttrKey)))
+		i += copy(dAtA[i:], m.AttrKey)
+	}
+	if len(m.AttrVals) > 0 {
+		for _, s := range m.AttrVals {
+			dAtA[i] = 0x22
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
+		}
 	}
 	if len(m.ColumnIDs) > 0 {
 		dAtA33 := make([]byte, len(m.ColumnIDs)*10)
@@ -3221,53 +3025,25 @@ func (m *ImportColumnAttrsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error
 			dAtA33[j32] = uint8(num)
 			j32++
 		}
-		i -= j32
-		copy(dAtA[i:], dAtA33[:j32])
-		i = encodeVarintPublic(dAtA, i, uint64(j32))
-		i--
 		dAtA[i] = 0x2a
+		i++
+		i = encodeVarintPublic(dAtA, i, uint64(j32))
+		i += copy(dAtA[i:], dAtA33[:j32])
 	}
-	if len(m.AttrVals) > 0 {
-		for iNdEx := len(m.AttrVals) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.AttrVals[iNdEx])
-			copy(dAtA[i:], m.AttrVals[iNdEx])
-			i = encodeVarintPublic(dAtA, i, uint64(len(m.AttrVals[iNdEx])))
-			i--
-			dAtA[i] = 0x22
-		}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	if len(m.AttrKey) > 0 {
-		i -= len(m.AttrKey)
-		copy(dAtA[i:], m.AttrKey)
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.AttrKey)))
-		i--
-		dAtA[i] = 0x1a
-	}
-	if m.Shard != 0 {
-		i = encodeVarintPublic(dAtA, i, uint64(m.Shard))
-		i--
-		dAtA[i] = 0x10
-	}
-	if len(m.Index) > 0 {
-		i -= len(m.Index)
-		copy(dAtA[i:], m.Index)
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func encodeVarintPublic(dAtA []byte, offset int, v uint64) int {
-	offset -= sovPublic(v)
-	base := offset
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
 		v >>= 7
 		offset++
 	}
 	dAtA[offset] = uint8(v)
-	return base
+	return offset + 1
 }
 func (m *Row) Size() (n int) {
 	if m == nil {
@@ -3778,6 +3554,12 @@ func (m *ImportValueRequest) Size() (n int) {
 	if len(m.FloatValues) > 0 {
 		n += 1 + sovPublic(uint64(len(m.FloatValues)*8)) + len(m.FloatValues)*8
 	}
+	if len(m.StringValues) > 0 {
+		for _, s := range m.StringValues {
+			l = len(s)
+			n += 1 + l + sovPublic(uint64(l))
+		}
+	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
 	}
@@ -3952,7 +3734,14 @@ func (m *ImportColumnAttrsRequest) Size() (n int) {
 }
 
 func sovPublic(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
 }
 func sozPublic(x uint64) (n int) {
 	return sovPublic(uint64((x << 1) ^ uint64((int64(x) >> 63))))
@@ -3972,7 +3761,7 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -3998,7 +3787,7 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= uint64(b&0x7F) << shift
+					v |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -4015,7 +3804,7 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= int(b&0x7F) << shift
+					packedLen |= (int(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -4024,15 +3813,12 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
-				if postIndex < 0 {
-					return ErrInvalidLengthPublic
-				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA[iNdEx:postIndex] {
+				for _, integer := range dAtA {
 					if integer < 128 {
 						count++
 					}
@@ -4052,7 +3838,7 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= uint64(b&0x7F) << shift
+						v |= (uint64(b) & 0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -4076,7 +3862,7 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4085,9 +3871,6 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4110,7 +3893,7 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4120,9 +3903,6 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4142,7 +3922,7 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= int(b&0x7F) << shift
+				byteLen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4151,9 +3931,6 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4171,9 +3948,6 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4202,7 +3976,7 @@ func (m *SignedRow) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -4230,7 +4004,7 @@ func (m *SignedRow) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4239,9 +4013,6 @@ func (m *SignedRow) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4266,7 +4037,7 @@ func (m *SignedRow) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4275,9 +4046,6 @@ func (m *SignedRow) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4297,9 +4065,6 @@ func (m *SignedRow) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4328,7 +4093,7 @@ func (m *RowIdentifiers) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -4354,7 +4119,7 @@ func (m *RowIdentifiers) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= uint64(b&0x7F) << shift
+					v |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -4371,7 +4136,7 @@ func (m *RowIdentifiers) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= int(b&0x7F) << shift
+					packedLen |= (int(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -4380,15 +4145,12 @@ func (m *RowIdentifiers) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
-				if postIndex < 0 {
-					return ErrInvalidLengthPublic
-				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA[iNdEx:postIndex] {
+				for _, integer := range dAtA {
 					if integer < 128 {
 						count++
 					}
@@ -4408,7 +4170,7 @@ func (m *RowIdentifiers) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= uint64(b&0x7F) << shift
+						v |= (uint64(b) & 0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -4432,7 +4194,7 @@ func (m *RowIdentifiers) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4442,9 +4204,6 @@ func (m *RowIdentifiers) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4459,9 +4218,6 @@ func (m *RowIdentifiers) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4490,7 +4246,7 @@ func (m *Pair) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -4518,7 +4274,7 @@ func (m *Pair) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.ID |= uint64(b&0x7F) << shift
+				m.ID |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4537,7 +4293,7 @@ func (m *Pair) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Count |= uint64(b&0x7F) << shift
+				m.Count |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4556,7 +4312,7 @@ func (m *Pair) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4566,9 +4322,6 @@ func (m *Pair) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4583,9 +4336,6 @@ func (m *Pair) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4614,7 +4364,7 @@ func (m *PairField) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -4642,7 +4392,7 @@ func (m *PairField) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4651,9 +4401,6 @@ func (m *PairField) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4678,7 +4425,7 @@ func (m *PairField) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4688,9 +4435,6 @@ func (m *PairField) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4705,9 +4449,6 @@ func (m *PairField) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4736,7 +4477,7 @@ func (m *PairsField) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -4764,7 +4505,7 @@ func (m *PairsField) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4773,9 +4514,6 @@ func (m *PairsField) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4798,7 +4536,7 @@ func (m *PairsField) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4808,9 +4546,6 @@ func (m *PairsField) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4825,9 +4560,6 @@ func (m *PairsField) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4856,7 +4588,7 @@ func (m *FieldRow) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -4884,7 +4616,7 @@ func (m *FieldRow) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4894,9 +4626,6 @@ func (m *FieldRow) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4916,7 +4645,7 @@ func (m *FieldRow) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.RowID |= uint64(b&0x7F) << shift
+				m.RowID |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4935,7 +4664,7 @@ func (m *FieldRow) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4945,9 +4674,6 @@ func (m *FieldRow) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4962,9 +4688,6 @@ func (m *FieldRow) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4993,7 +4716,7 @@ func (m *GroupCount) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5021,7 +4744,7 @@ func (m *GroupCount) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5030,9 +4753,6 @@ func (m *GroupCount) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5055,7 +4775,7 @@ func (m *GroupCount) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Count |= uint64(b&0x7F) << shift
+				m.Count |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5074,7 +4794,7 @@ func (m *GroupCount) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Sum |= int64(b&0x7F) << shift
+				m.Sum |= (int64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5088,9 +4808,6 @@ func (m *GroupCount) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5119,7 +4836,7 @@ func (m *ValCount) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5147,7 +4864,7 @@ func (m *ValCount) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Val |= int64(b&0x7F) << shift
+				m.Val |= (int64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5166,7 +4883,7 @@ func (m *ValCount) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Count |= int64(b&0x7F) << shift
+				m.Count |= (int64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5180,9 +4897,6 @@ func (m *ValCount) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5211,7 +4925,7 @@ func (m *ColumnAttrSet) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5239,7 +4953,7 @@ func (m *ColumnAttrSet) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.ID |= uint64(b&0x7F) << shift
+				m.ID |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5258,7 +4972,7 @@ func (m *ColumnAttrSet) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5267,9 +4981,6 @@ func (m *ColumnAttrSet) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5292,7 +5003,7 @@ func (m *ColumnAttrSet) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5302,9 +5013,6 @@ func (m *ColumnAttrSet) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5319,9 +5027,6 @@ func (m *ColumnAttrSet) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5350,7 +5055,7 @@ func (m *Attr) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5378,7 +5083,7 @@ func (m *Attr) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5388,9 +5093,6 @@ func (m *Attr) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5410,7 +5112,7 @@ func (m *Attr) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Type |= uint64(b&0x7F) << shift
+				m.Type |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5429,7 +5131,7 @@ func (m *Attr) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5439,9 +5141,6 @@ func (m *Attr) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5461,7 +5160,7 @@ func (m *Attr) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.IntValue |= int64(b&0x7F) << shift
+				m.IntValue |= (int64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5480,7 +5179,7 @@ func (m *Attr) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				v |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5506,9 +5205,6 @@ func (m *Attr) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5537,7 +5233,7 @@ func (m *AttrMap) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5565,7 +5261,7 @@ func (m *AttrMap) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5574,9 +5270,6 @@ func (m *AttrMap) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5594,9 +5287,6 @@ func (m *AttrMap) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5625,7 +5315,7 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5653,7 +5343,7 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5663,9 +5353,6 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5683,7 +5370,7 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= uint64(b&0x7F) << shift
+					v |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -5700,7 +5387,7 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= int(b&0x7F) << shift
+					packedLen |= (int(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -5709,15 +5396,12 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
-				if postIndex < 0 {
-					return ErrInvalidLengthPublic
-				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA[iNdEx:postIndex] {
+				for _, integer := range dAtA {
 					if integer < 128 {
 						count++
 					}
@@ -5737,7 +5421,7 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= uint64(b&0x7F) << shift
+						v |= (uint64(b) & 0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -5761,7 +5445,7 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				v |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5781,7 +5465,7 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				v |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5801,7 +5485,7 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				v |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5821,7 +5505,7 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				v |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5841,7 +5525,7 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5850,9 +5534,6 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5870,9 +5551,6 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5901,7 +5579,7 @@ func (m *QueryResponse) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5929,7 +5607,7 @@ func (m *QueryResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5939,9 +5617,6 @@ func (m *QueryResponse) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5961,7 +5636,7 @@ func (m *QueryResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5970,9 +5645,6 @@ func (m *QueryResponse) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5995,7 +5667,7 @@ func (m *QueryResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6004,9 +5676,6 @@ func (m *QueryResponse) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6024,9 +5693,6 @@ func (m *QueryResponse) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6055,7 +5721,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -6083,7 +5749,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6092,9 +5758,6 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6119,7 +5782,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.N |= uint64(b&0x7F) << shift
+				m.N |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6138,7 +5801,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6147,9 +5810,6 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6172,7 +5832,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				v |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6192,7 +5852,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6201,9 +5861,6 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6228,7 +5885,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Type |= uint32(b&0x7F) << shift
+				m.Type |= (uint32(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6245,7 +5902,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= uint64(b&0x7F) << shift
+					v |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -6262,7 +5919,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= int(b&0x7F) << shift
+					packedLen |= (int(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -6271,15 +5928,12 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
-				if postIndex < 0 {
-					return ErrInvalidLengthPublic
-				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA[iNdEx:postIndex] {
+				for _, integer := range dAtA {
 					if integer < 128 {
 						count++
 					}
@@ -6299,7 +5953,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= uint64(b&0x7F) << shift
+						v |= (uint64(b) & 0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -6323,7 +5977,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6332,9 +5986,6 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6357,7 +6008,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6366,9 +6017,6 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6393,7 +6041,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6402,9 +6050,6 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6429,7 +6074,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6438,9 +6083,6 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6460,9 +6102,6 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6491,7 +6130,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -6519,7 +6158,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6529,9 +6168,6 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6551,7 +6187,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6561,9 +6197,6 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6583,7 +6216,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Shard |= uint64(b&0x7F) << shift
+				m.Shard |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6600,7 +6233,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= uint64(b&0x7F) << shift
+					v |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -6617,7 +6250,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= int(b&0x7F) << shift
+					packedLen |= (int(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -6626,15 +6259,12 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
-				if postIndex < 0 {
-					return ErrInvalidLengthPublic
-				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA[iNdEx:postIndex] {
+				for _, integer := range dAtA {
 					if integer < 128 {
 						count++
 					}
@@ -6654,7 +6284,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= uint64(b&0x7F) << shift
+						v |= (uint64(b) & 0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -6676,7 +6306,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= uint64(b&0x7F) << shift
+					v |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -6693,7 +6323,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= int(b&0x7F) << shift
+					packedLen |= (int(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -6702,15 +6332,12 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
-				if postIndex < 0 {
-					return ErrInvalidLengthPublic
-				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA[iNdEx:postIndex] {
+				for _, integer := range dAtA {
 					if integer < 128 {
 						count++
 					}
@@ -6730,7 +6357,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= uint64(b&0x7F) << shift
+						v |= (uint64(b) & 0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -6752,7 +6379,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= int64(b&0x7F) << shift
+					v |= (int64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -6769,7 +6396,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= int(b&0x7F) << shift
+					packedLen |= (int(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -6778,15 +6405,12 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
-				if postIndex < 0 {
-					return ErrInvalidLengthPublic
-				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA[iNdEx:postIndex] {
+				for _, integer := range dAtA {
 					if integer < 128 {
 						count++
 					}
@@ -6806,7 +6430,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= int64(b&0x7F) << shift
+						v |= (int64(b) & 0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -6830,7 +6454,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6840,9 +6464,6 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6862,7 +6483,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6872,9 +6493,6 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6889,9 +6507,6 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6920,7 +6535,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -6948,7 +6563,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6958,9 +6573,6 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6980,7 +6592,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6990,9 +6602,6 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7012,7 +6621,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Shard |= uint64(b&0x7F) << shift
+				m.Shard |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7029,7 +6638,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= uint64(b&0x7F) << shift
+					v |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -7046,7 +6655,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= int(b&0x7F) << shift
+					packedLen |= (int(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -7055,15 +6664,12 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
-				if postIndex < 0 {
-					return ErrInvalidLengthPublic
-				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA[iNdEx:postIndex] {
+				for _, integer := range dAtA {
 					if integer < 128 {
 						count++
 					}
@@ -7083,7 +6689,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= uint64(b&0x7F) << shift
+						v |= (uint64(b) & 0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -7105,7 +6711,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= int64(b&0x7F) << shift
+					v |= (int64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -7122,7 +6728,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= int(b&0x7F) << shift
+					packedLen |= (int(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -7131,15 +6737,12 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
-				if postIndex < 0 {
-					return ErrInvalidLengthPublic
-				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA[iNdEx:postIndex] {
+				for _, integer := range dAtA {
 					if integer < 128 {
 						count++
 					}
@@ -7159,7 +6762,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= int64(b&0x7F) << shift
+						v |= (int64(b) & 0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -7183,7 +6786,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7193,9 +6796,6 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7222,7 +6822,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= int(b&0x7F) << shift
+					packedLen |= (int(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -7231,9 +6831,6 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
-				if postIndex < 0 {
-					return ErrInvalidLengthPublic
-				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
@@ -7255,6 +6852,35 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 			} else {
 				return fmt.Errorf("proto: wrong wireType = %d for field FloatValues", wireType)
 			}
+		case 9:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field StringValues", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPublic
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthPublic
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.StringValues = append(m.StringValues, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipPublic(dAtA[iNdEx:])
@@ -7264,9 +6890,6 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7295,7 +6918,7 @@ func (m *TranslateKeysRequest) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7323,7 +6946,7 @@ func (m *TranslateKeysRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7333,9 +6956,6 @@ func (m *TranslateKeysRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7355,7 +6975,7 @@ func (m *TranslateKeysRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7365,9 +6985,6 @@ func (m *TranslateKeysRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7387,7 +7004,7 @@ func (m *TranslateKeysRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7397,9 +7014,6 @@ func (m *TranslateKeysRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7414,9 +7028,6 @@ func (m *TranslateKeysRequest) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7445,7 +7056,7 @@ func (m *TranslateKeysResponse) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7471,7 +7082,7 @@ func (m *TranslateKeysResponse) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= uint64(b&0x7F) << shift
+					v |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -7488,7 +7099,7 @@ func (m *TranslateKeysResponse) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= int(b&0x7F) << shift
+					packedLen |= (int(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -7497,15 +7108,12 @@ func (m *TranslateKeysResponse) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
-				if postIndex < 0 {
-					return ErrInvalidLengthPublic
-				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA[iNdEx:postIndex] {
+				for _, integer := range dAtA {
 					if integer < 128 {
 						count++
 					}
@@ -7525,7 +7133,7 @@ func (m *TranslateKeysResponse) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= uint64(b&0x7F) << shift
+						v |= (uint64(b) & 0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -7544,9 +7152,6 @@ func (m *TranslateKeysResponse) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7575,7 +7180,7 @@ func (m *TranslateIDsRequest) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7603,7 +7208,7 @@ func (m *TranslateIDsRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7613,9 +7218,6 @@ func (m *TranslateIDsRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7635,7 +7237,7 @@ func (m *TranslateIDsRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7645,9 +7247,6 @@ func (m *TranslateIDsRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7665,7 +7264,7 @@ func (m *TranslateIDsRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= uint64(b&0x7F) << shift
+					v |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -7682,7 +7281,7 @@ func (m *TranslateIDsRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= int(b&0x7F) << shift
+					packedLen |= (int(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -7691,15 +7290,12 @@ func (m *TranslateIDsRequest) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
-				if postIndex < 0 {
-					return ErrInvalidLengthPublic
-				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA[iNdEx:postIndex] {
+				for _, integer := range dAtA {
 					if integer < 128 {
 						count++
 					}
@@ -7719,7 +7315,7 @@ func (m *TranslateIDsRequest) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= uint64(b&0x7F) << shift
+						v |= (uint64(b) & 0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -7738,9 +7334,6 @@ func (m *TranslateIDsRequest) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7769,7 +7362,7 @@ func (m *TranslateIDsResponse) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7797,7 +7390,7 @@ func (m *TranslateIDsResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7807,9 +7400,6 @@ func (m *TranslateIDsResponse) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7824,9 +7414,6 @@ func (m *TranslateIDsResponse) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7855,7 +7442,7 @@ func (m *ImportRoaringRequestView) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7883,7 +7470,7 @@ func (m *ImportRoaringRequestView) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7893,9 +7480,6 @@ func (m *ImportRoaringRequestView) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7915,7 +7499,7 @@ func (m *ImportRoaringRequestView) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= int(b&0x7F) << shift
+				byteLen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7924,9 +7508,6 @@ func (m *ImportRoaringRequestView) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7944,9 +7525,6 @@ func (m *ImportRoaringRequestView) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7975,7 +7553,7 @@ func (m *ImportRoaringRequest) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -8003,7 +7581,7 @@ func (m *ImportRoaringRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				v |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8023,7 +7601,7 @@ func (m *ImportRoaringRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				msglen |= (int(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8032,9 +7610,6 @@ func (m *ImportRoaringRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8052,9 +7627,6 @@ func (m *ImportRoaringRequest) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8083,7 +7655,7 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= uint64(b&0x7F) << shift
+			wire |= (uint64(b) & 0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -8111,7 +7683,7 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8121,9 +7693,6 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8143,7 +7712,7 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Shard |= int64(b&0x7F) << shift
+				m.Shard |= (int64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8162,7 +7731,7 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8172,9 +7741,6 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8194,7 +7760,7 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				stringLen |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8204,9 +7770,6 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8224,7 +7787,7 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= uint64(b&0x7F) << shift
+					v |= (uint64(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -8241,7 +7804,7 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= int(b&0x7F) << shift
+					packedLen |= (int(b) & 0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -8250,15 +7813,12 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
-				if postIndex < 0 {
-					return ErrInvalidLengthPublic
-				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA[iNdEx:postIndex] {
+				for _, integer := range dAtA {
 					if integer < 128 {
 						count++
 					}
@@ -8278,7 +7838,7 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= uint64(b&0x7F) << shift
+						v |= (uint64(b) & 0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -8297,9 +7857,6 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthPublic
-			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8316,7 +7873,6 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 func skipPublic(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
-	depth := 0
 	for iNdEx < l {
 		var wire uint64
 		for shift := uint(0); ; shift += 7 {
@@ -8348,8 +7904,10 @@ func skipPublic(dAtA []byte) (n int, err error) {
 					break
 				}
 			}
+			return iNdEx, nil
 		case 1:
 			iNdEx += 8
+			return iNdEx, nil
 		case 2:
 			var length int
 			for shift := uint(0); ; shift += 7 {
@@ -8366,34 +7924,128 @@ func skipPublic(dAtA []byte) (n int, err error) {
 					break
 				}
 			}
+			iNdEx += length
 			if length < 0 {
 				return 0, ErrInvalidLengthPublic
 			}
-			iNdEx += length
+			return iNdEx, nil
 		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupPublic
+			for {
+				var innerWire uint64
+				var start int = iNdEx
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return 0, ErrIntOverflowPublic
+					}
+					if iNdEx >= l {
+						return 0, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					innerWire |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				innerWireType := int(innerWire & 0x7)
+				if innerWireType == 4 {
+					break
+				}
+				next, err := skipPublic(dAtA[start:])
+				if err != nil {
+					return 0, err
+				}
+				iNdEx = start + next
 			}
-			depth--
+			return iNdEx, nil
+		case 4:
+			return iNdEx, nil
 		case 5:
 			iNdEx += 4
+			return iNdEx, nil
 		default:
 			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
 		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthPublic
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
 	}
-	return 0, io.ErrUnexpectedEOF
+	panic("unreachable")
 }
 
 var (
-	ErrInvalidLengthPublic        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowPublic          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupPublic = fmt.Errorf("proto: unexpected end of group")
+	ErrInvalidLengthPublic = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowPublic   = fmt.Errorf("proto: integer overflow")
 )
+
+func init() { proto.RegisterFile("public.proto", fileDescriptor_public_34478dbd0ceb9d33) }
+
+var fileDescriptor_public_34478dbd0ceb9d33 = []byte{
+	// 1097 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcd, 0x8e, 0x1b, 0x45,
+	0x10, 0xa6, 0x3d, 0xf6, 0xda, 0x2e, 0x7b, 0x97, 0xa8, 0xe3, 0x84, 0x11, 0x8a, 0x16, 0xab, 0x15,
+	0xa1, 0x81, 0xc3, 0x46, 0x59, 0x10, 0xca, 0x89, 0x9f, 0x8d, 0x37, 0x60, 0x45, 0xb1, 0x42, 0x79,
+	0x65, 0x6e, 0x48, 0xb3, 0x71, 0x67, 0x33, 0xd2, 0x78, 0xc6, 0xcc, 0x0f, 0xce, 0x3e, 0x07, 0x17,
+	0xc4, 0x13, 0xf0, 0x0e, 0xbc, 0x00, 0x47, 0x1e, 0x01, 0x96, 0x37, 0xe0, 0xca, 0x05, 0x55, 0xf5,
+	0xb4, 0x7b, 0xec, 0xfd, 0x01, 0x45, 0xdc, 0xfa, 0xab, 0xaa, 0xae, 0xae, 0xaa, 0xae, 0xfa, 0xba,
+	0xa1, 0xbf, 0x2c, 0x4f, 0xe3, 0xe8, 0xc5, 0xc1, 0x32, 0x4b, 0x8b, 0x54, 0x76, 0xa2, 0xa4, 0xd0,
+	0x59, 0x12, 0xc6, 0x2a, 0x07, 0x0f, 0xd3, 0x95, 0xf4, 0xa1, 0xfd, 0x38, 0x8d, 0xcb, 0x45, 0x92,
+	0xfb, 0x62, 0xe8, 0x05, 0x4d, 0xb4, 0x50, 0xde, 0x87, 0xd6, 0x17, 0x45, 0x91, 0xe5, 0x7e, 0x63,
+	0xe8, 0x05, 0xbd, 0xc3, 0xbd, 0x03, 0xbb, 0xf5, 0x80, 0xc4, 0x68, 0x94, 0x52, 0x42, 0xf3, 0xa9,
+	0x3e, 0xcf, 0x7d, 0x6f, 0xe8, 0x05, 0x5d, 0xe4, 0x35, 0xf9, 0xc4, 0x34, 0xcc, 0xa2, 0xe4, 0xcc,
+	0x6f, 0x0e, 0x45, 0xd0, 0x47, 0x0b, 0xd5, 0x33, 0xe8, 0x4e, 0xa3, 0xb3, 0x44, 0xcf, 0xe9, 0xe8,
+	0xf7, 0xc0, 0x7b, 0x9e, 0xd2, 0xb1, 0x22, 0xe8, 0x1d, 0xee, 0x3a, 0xf7, 0x98, 0xae, 0x90, 0x34,
+	0x64, 0x30, 0xd1, 0x67, 0x7e, 0xe3, 0x4a, 0x83, 0x89, 0x3e, 0x53, 0x8f, 0x60, 0x0f, 0xd3, 0xd5,
+	0x78, 0xae, 0x93, 0x22, 0x7a, 0x19, 0x69, 0x13, 0x0e, 0xa6, 0x2b, 0x9b, 0x0b, 0xaf, 0xd7, 0x21,
+	0x36, 0x5c, 0x88, 0xea, 0x53, 0x68, 0x3e, 0x0f, 0xa3, 0x4c, 0xee, 0x41, 0x63, 0x3c, 0xe2, 0x10,
+	0x9a, 0xd8, 0x18, 0x8f, 0xe4, 0x00, 0x5a, 0x8f, 0xd3, 0x32, 0x29, 0xf8, 0xd0, 0x26, 0x1a, 0x20,
+	0x6f, 0x81, 0xf7, 0x54, 0x9f, 0xfb, 0xde, 0x50, 0x04, 0x5d, 0xa4, 0xa5, 0x3a, 0x86, 0x2e, 0xed,
+	0x7f, 0x12, 0xe9, 0x78, 0x2e, 0x95, 0x71, 0x56, 0x65, 0x52, 0x2b, 0x14, 0x49, 0xd1, 0x1c, 0x34,
+	0x80, 0x16, 0x1b, 0xb3, 0xe3, 0x2e, 0x1a, 0xa0, 0xbe, 0x02, 0x20, 0x6d, 0x6e, 0xfc, 0xdc, 0x87,
+	0x16, 0x23, 0x8e, 0xfe, 0xb2, 0x23, 0xa3, 0xbc, 0xc6, 0xd3, 0x04, 0x3a, 0xbc, 0xa0, 0xc2, 0xae,
+	0x2d, 0x44, 0xcd, 0x82, 0xa4, 0x54, 0xac, 0x91, 0x4d, 0x8d, 0x81, 0xbc, 0x0b, 0x3b, 0x98, 0xae,
+	0x5c, 0x76, 0x15, 0x52, 0xdf, 0x02, 0x7c, 0x99, 0xa5, 0xe5, 0xd2, 0x14, 0x20, 0x80, 0x16, 0xa3,
+	0x2a, 0x32, 0xe9, 0x22, 0xb3, 0x87, 0xa2, 0x31, 0xb8, 0xbe, 0x80, 0xd3, 0x72, 0xc1, 0x47, 0x78,
+	0x48, 0x4b, 0x75, 0x08, 0x9d, 0x59, 0x18, 0xaf, 0xb5, 0xb3, 0x30, 0xe6, 0x68, 0x3d, 0xa4, 0xe5,
+	0xa6, 0x17, 0xaf, 0xf2, 0xa2, 0xbe, 0x81, 0x5d, 0xd3, 0x9c, 0xd4, 0x7a, 0x53, 0x5d, 0x5c, 0xba,
+	0xbd, 0xff, 0xd6, 0xb2, 0x97, 0x6f, 0xf3, 0x67, 0x01, 0x4d, 0xd2, 0x59, 0x95, 0x58, 0xab, 0xa8,
+	0x79, 0x4e, 0xce, 0x97, 0xba, 0x4a, 0x87, 0xd7, 0x72, 0x08, 0xbd, 0x69, 0x41, 0xfd, 0x3c, 0x0b,
+	0xe3, 0x52, 0x57, 0x8e, 0xea, 0x22, 0xf9, 0x2e, 0x74, 0xc6, 0x49, 0x61, 0xd4, 0x4d, 0x4e, 0x61,
+	0x8d, 0xe5, 0x3d, 0xe8, 0x1e, 0xa5, 0x69, 0x6c, 0x94, 0xad, 0xa1, 0x08, 0x3a, 0xe8, 0x04, 0x72,
+	0x1f, 0xe0, 0x49, 0x9c, 0x86, 0xd5, 0xde, 0x9d, 0xa1, 0x08, 0x04, 0xd6, 0x24, 0xea, 0x01, 0xb4,
+	0x29, 0xd2, 0x67, 0xe1, 0xd2, 0x65, 0x2b, 0x6e, 0xc8, 0x56, 0xfd, 0x2d, 0xa0, 0xff, 0x75, 0xa9,
+	0xb3, 0x73, 0xd4, 0xdf, 0x95, 0x3a, 0x2f, 0xa8, 0xb6, 0x8c, 0x6d, 0x77, 0x30, 0xa0, 0x3e, 0x98,
+	0xbe, 0x0a, 0xb3, 0xb9, 0xa9, 0x5d, 0x13, 0x2b, 0x44, 0xb9, 0xba, 0x9a, 0xe7, 0x9c, 0x6b, 0x07,
+	0xeb, 0x22, 0xee, 0x20, 0xbd, 0x48, 0x0b, 0x9b, 0x4c, 0x85, 0x64, 0x00, 0x6f, 0x1f, 0xbf, 0x7e,
+	0x11, 0x97, 0x73, 0x8d, 0xe9, 0xca, 0xec, 0xde, 0x61, 0x83, 0x6d, 0xb1, 0x7c, 0x1f, 0xf6, 0x2a,
+	0x91, 0xa5, 0xa2, 0x36, 0x1b, 0x6e, 0x49, 0xe5, 0x43, 0xe8, 0x1f, 0x2f, 0x4e, 0xf5, 0x7c, 0xae,
+	0xe7, 0xa3, 0xb0, 0x08, 0xfd, 0x0e, 0xe7, 0xbd, 0x45, 0x0c, 0x1b, 0x26, 0xea, 0x07, 0x01, 0xbb,
+	0x55, 0xf6, 0xf9, 0x32, 0x4d, 0x72, 0x4d, 0x57, 0x7c, 0x9c, 0x65, 0xf6, 0x8a, 0x8f, 0xb3, 0x4c,
+	0x3e, 0x80, 0x36, 0xea, 0xbc, 0x8c, 0x0b, 0xdb, 0x37, 0x77, 0x9c, 0x47, 0xbb, 0xb7, 0x8c, 0x0b,
+	0xb4, 0x56, 0xf2, 0x33, 0xd8, 0xdb, 0xe8, 0x43, 0xc3, 0x7e, 0xbd, 0xc3, 0x77, 0xdc, 0xbe, 0x0d,
+	0x3d, 0x6e, 0x99, 0xab, 0x5f, 0x3c, 0xe8, 0xd5, 0x3c, 0x13, 0xd1, 0x61, 0xba, 0xba, 0x86, 0x09,
+	0x69, 0xa2, 0xfb, 0x20, 0x26, 0x55, 0x0b, 0x8a, 0x89, 0xe3, 0x09, 0xef, 0x26, 0x9e, 0x20, 0x66,
+	0x7f, 0x15, 0x26, 0x67, 0x7a, 0xce, 0x2d, 0xd8, 0x41, 0x0b, 0xe5, 0x81, 0x9b, 0x3d, 0xbe, 0xb3,
+	0x8d, 0x81, 0xb6, 0x1a, 0x74, 0xf3, 0x69, 0x67, 0x80, 0xae, 0x6f, 0xb7, 0x9a, 0x01, 0xc3, 0x1b,
+	0xe3, 0x11, 0xdd, 0x15, 0xf7, 0x8b, 0x41, 0xf2, 0x13, 0xe8, 0x39, 0xde, 0xc8, 0xab, 0x2b, 0x1a,
+	0x38, 0xf7, 0x4e, 0x89, 0x75, 0x43, 0xf9, 0xf9, 0x36, 0x95, 0xfb, 0x5d, 0x8e, 0xcc, 0xdf, 0xa8,
+	0x46, 0x4d, 0x8f, 0xdb, 0xd4, 0xff, 0xb0, 0xf6, 0xb6, 0xf8, 0xc0, 0x9b, 0x6f, 0xbb, 0xcd, 0x6b,
+	0x15, 0xd6, 0x5e, 0xa0, 0x8f, 0xeb, 0xf4, 0xeb, 0xf7, 0x78, 0xcf, 0x60, 0xb3, 0x9a, 0x46, 0x87,
+	0x35, 0x3b, 0xf5, 0x87, 0x80, 0xdd, 0xf1, 0x62, 0x99, 0x66, 0x45, 0x6d, 0xa4, 0xc6, 0xc9, 0x5c,
+	0xbf, 0xb6, 0x23, 0xc5, 0xe0, 0x6a, 0xa2, 0x26, 0x29, 0x8f, 0x16, 0x8f, 0x52, 0x13, 0x0d, 0xa8,
+	0x95, 0xb3, 0xb9, 0x51, 0xce, 0x7b, 0xd0, 0x35, 0xbd, 0x43, 0xaa, 0x16, 0xab, 0x9c, 0x80, 0xc8,
+	0xe2, 0x24, 0x5a, 0xe8, 0xbc, 0x08, 0x17, 0x4b, 0x9a, 0x2e, 0x2f, 0xf0, 0xb0, 0x26, 0x31, 0x0f,
+	0xf1, 0x8a, 0x1f, 0xbf, 0x36, 0x3f, 0x7e, 0x16, 0xd2, 0x4e, 0xe3, 0x86, 0x95, 0x1d, 0x56, 0xd6,
+	0x24, 0xea, 0x2f, 0x01, 0xd2, 0xe4, 0xc8, 0xb4, 0xf3, 0xff, 0x25, 0x7a, 0x73, 0x42, 0x77, 0x61,
+	0x87, 0xcf, 0xb3, 0xc9, 0x54, 0x68, 0x2b, 0xdc, 0xf6, 0x76, 0xb8, 0xc4, 0x52, 0x8e, 0x23, 0x4d,
+	0x3e, 0x02, 0xeb, 0x22, 0xa9, 0xa0, 0x5f, 0x23, 0x68, 0xea, 0x2e, 0xf2, 0xb1, 0x21, 0x53, 0x33,
+	0x18, 0x9c, 0x64, 0x61, 0x92, 0xc7, 0x61, 0xa1, 0xc9, 0xed, 0x9b, 0x64, 0x7d, 0xc5, 0x7f, 0x48,
+	0x7d, 0x00, 0x77, 0xb6, 0xfc, 0x3a, 0x2e, 0xa2, 0x32, 0x78, 0x5c, 0x06, 0x5a, 0xaa, 0x29, 0xdc,
+	0x5e, 0x9b, 0x8e, 0x47, 0x6f, 0x14, 0xc1, 0x65, 0xa7, 0x1f, 0xd6, 0xf2, 0x62, 0xa7, 0xd5, 0xf1,
+	0x57, 0xc5, 0x7a, 0x04, 0x7e, 0xd5, 0xdb, 0xe6, 0xcb, 0x56, 0x45, 0x30, 0x8b, 0xf4, 0x8a, 0xec,
+	0x27, 0xe1, 0x42, 0x57, 0x41, 0xf0, 0x9a, 0x64, 0xcc, 0xc5, 0x0d, 0xfe, 0xe8, 0xf1, 0x5a, 0xbd,
+	0x84, 0xc1, 0x55, 0x3e, 0xf8, 0x55, 0x8f, 0x75, 0x68, 0xc8, 0xb7, 0x83, 0x06, 0xc8, 0x47, 0xd0,
+	0xfa, 0x3e, 0xd2, 0x2b, 0x4b, 0xbe, 0xca, 0xcd, 0xdf, 0x75, 0x81, 0xa0, 0xd9, 0xa0, 0x7e, 0x12,
+	0x36, 0xd8, 0xda, 0x7b, 0xf4, 0xaf, 0x25, 0x33, 0x4d, 0x59, 0x7d, 0x2c, 0x4c, 0x53, 0xfa, 0xe6,
+	0x51, 0x75, 0xbf, 0x02, 0x0b, 0xe9, 0x21, 0xa7, 0xe5, 0x2c, 0x8c, 0xcd, 0x64, 0x76, 0x71, 0x8d,
+	0x6f, 0x6e, 0xe5, 0xa3, 0x5b, 0xbf, 0x5e, 0xec, 0x8b, 0xdf, 0x2e, 0xf6, 0xc5, 0xef, 0x17, 0xfb,
+	0xe2, 0xc7, 0x3f, 0xf7, 0xdf, 0x3a, 0xdd, 0xe1, 0x2f, 0xf8, 0x47, 0xff, 0x04, 0x00, 0x00, 0xff,
+	0xff, 0x7f, 0x3f, 0x32, 0x93, 0x92, 0x0b, 0x00, 0x00,
+}
diff --git a/internal/public.proto b/internal/public.proto
index fcedd24cf..7ba89bd75 100644
--- a/internal/public.proto
+++ b/internal/public.proto
@@ -120,6 +120,7 @@ message ImportValueRequest {
 	repeated string ColumnKeys = 7;
 	repeated int64 Values = 6;
 	repeated double FloatValues = 8;
+	repeated string StringValues = 9;
 }
 
 message TranslateKeysRequest {
diff --git a/pilosa.go b/pilosa.go
index 42ab3d3c1..3f1e8545b 100644
--- a/pilosa.go
+++ b/pilosa.go
@@ -29,6 +29,8 @@ var (
 	ErrIndexExists   = errors.New("index already exists")
 	ErrIndexNotFound = errors.New("index not found")
 
+	ErrForeignIndexNotFound = errors.New("foreign index not found")
+
 	// ErrFieldRequired is returned when no field is specified.
 	ErrFieldRequired = errors.New("field required")
 	ErrFieldExists   = errors.New("field already exists")
@@ -48,7 +50,7 @@ var (
 	ErrInvalidView      = errors.New("invalid view")
 	ErrInvalidCacheType = errors.New("invalid cache type")
 
-	ErrName  = errors.New("invalid index or field name, must match [a-z][a-z0-9_-]* and contain at most 64 characters")
+	ErrName  = errors.New("invalid index or field name, must match [a-z][a-z0-9_-]* and contain at most 230 characters")
 	ErrLabel = errors.New("invalid row or column label, must match [A-Za-z0-9_-]")
 
 	// ErrFragmentNotFound is returned when a fragment does not exist.
@@ -118,7 +120,7 @@ func newNotFoundError(err error) NotFoundError {
 }
 
 // Regular expression to validate index and field names.
-var nameRegexp = regexp.MustCompile(`^[a-z][a-z0-9_-]{0,63}$`)
+var nameRegexp = regexp.MustCompile(`^[a-z][a-z0-9_-]{0,229}$`)
 
 // ColumnAttrSet represents a set of attributes for a vertical column in an index.
 // Can have a set of attributes attached to it.
diff --git a/pilosa_internal_test.go b/pilosa_internal_test.go
index 40e33ac4b..4abe89072 100644
--- a/pilosa_internal_test.go
+++ b/pilosa_internal_test.go
@@ -21,7 +21,7 @@ import (
 func TestValidateName(t *testing.T) {
 	names := []string{
 		"a", "ab", "ab1", "b-c", "d_e", "exists",
-		"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+		"longbutnottoolongaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa12345689012345689012345678901234567890",
 	}
 	for _, name := range names {
 		if validateName(name) != nil {
@@ -33,7 +33,7 @@ func TestValidateName(t *testing.T) {
 func TestValidateNameInvalid(t *testing.T) {
 	names := []string{
 		"", "'", "^", "/", "\\", "A", "*", "a:b", "valid?no", "yüce", "1", "_", "-",
-		"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1", "_exists",
+		"long123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1", "_exists",
 	}
 	for _, name := range names {
 		if validateName(name) == nil {
diff --git a/roaring/roaring.go b/roaring/roaring.go
index bb0479f8f..19a671dbf 100644
--- a/roaring/roaring.go
+++ b/roaring/roaring.go
@@ -422,7 +422,11 @@ func (b *Bitmap) remove(v uint64) bool {
 	c := b.Containers.Get(highbits(v))
 	newC, changed := c.remove(lowbits(v))
 	if newC != c {
-		b.Containers.Put(highbits(v), newC)
+		if newC != nil {
+			b.Containers.Put(highbits(v), newC)
+		} else {
+			b.Containers.Remove(highbits(v))
+		}
 	}
 	return changed
 }
diff --git a/server.go b/server.go
index 722ad0488..19e20b074 100644
--- a/server.go
+++ b/server.go
@@ -382,7 +382,7 @@ func NewServer(opts ...ServerOption) (*Server, error) {
 	s.cluster.broadcaster = s
 	s.cluster.maxWritesPerRequest = s.maxWritesPerRequest
 	s.holder.broadcaster = s
-	err = s.loadExtensions()
+	err = s.loadAllExtensions()
 	if err != nil {
 		s.logger.Printf("not all plugins loaded successfully")
 	}
@@ -419,8 +419,18 @@ func (s *Server) InternalClient() InternalClient {
 	return s.defaultClient
 }
 
-func (s *Server) loadExtensions() error {
-	exts := ext.NewExtensions()
+// loadNewExtensions loads extensions that have been
+// registered since the last call to loadNewExtensions.
+func (s *Server) loadNewExtensions() error { //nolint:unused
+	return s.loadExtensions(ext.NewExtensions())
+}
+
+// loadAllExtensions loads all extensions.
+func (s *Server) loadAllExtensions() error {
+	return s.loadExtensions(ext.AllExtensions())
+}
+
+func (s *Server) loadExtensions(exts []*ext.ExtensionInfo) error {
 	var lastError error
 	for _, extension := range exts {
 		if err := s.loadExtension(extension); err != nil {
@@ -438,8 +448,6 @@ func (s *Server) loadExtension(extInfo *ext.ExtensionInfo) error {
 	bitmapOps := extInfo.BitmapOps
 	bmOps, countOps, fieldOps, unknownOps := 0, 0, 0, 0
 	for i := range bitmapOps {
-		// title-case the name
-		bitmapOps[i].Name = strings.Title(bitmapOps[i].Name)
 		typ := bitmapOps[i].Func.BitmapOpType()
 		switch {
 		case typ.Input == ext.OpInputBitmap && typ.Output == ext.OpOutputCount:
diff --git a/server/grpc.go b/server/grpc.go
index 7749fff1a..4d410546f 100644
--- a/server/grpc.go
+++ b/server/grpc.go
@@ -19,6 +19,7 @@ import (
 	"crypto/tls"
 	"fmt"
 	"net"
+	"strings"
 
 	"github.com/pilosa/pilosa/v2"
 	"github.com/pilosa/pilosa/v2/logger"
@@ -79,13 +80,20 @@ func (h grpcHandler) QueryPQL(req *pb.QueryPQLRequest, stream pb.Pilosa_QueryPQL
 // uint64, bool, etc.) based on the Pilosa field type.
 func fieldDataType(f *pilosa.Field) string {
 	switch f.Type() {
-	case "set", "mutex":
-		if f.Options().Keys {
+	case "set":
+		if f.Keys() {
 			return "[]string"
-		} else {
-			return "[]uint64"
 		}
+		return "[]uint64"
+	case "mutex":
+		if f.Keys() {
+			return "string"
+		}
+		return "uint64"
 	case "int":
+		if f.Keys() {
+			return "string"
+		}
 		return "int64"
 	case "decimal":
 		return "float64"
@@ -109,6 +117,10 @@ func (h grpcHandler) Inspect(req *pb.InspectRequest, stream pb.Pilosa_InspectSer
 
 	var fields []*pilosa.Field
 	for _, field := range index.Fields() {
+		// exclude internal fields (starting with "_")
+		if strings.HasPrefix(field.Name(), "_") {
+			continue
+		}
 		if len(req.FilterFields) > 0 {
 			for _, filter := range req.FilterFields {
 				if filter == field.Name() {
@@ -128,7 +140,7 @@ func (h grpcHandler) Inspect(req *pb.InspectRequest, stream pb.Pilosa_InspectSer
 	}
 	offset := req.Offset
 
-	if !index.Options().Keys {
+	if !index.Keys() {
 		ints, ok := req.Columns.Type.(*pb.IdsOrKeys_Ids)
 		if !ok {
 			return errors.New("invalid int columns")
@@ -243,15 +255,28 @@ func (h grpcHandler) Inspect(req *pb.InspectRequest, stream pb.Pilosa_InspectSer
 					}
 
 				case "int":
-					value, exists, err := field.Value(col)
-					if err != nil {
-						return errors.Wrap(err, "getting int field value for column")
-					} else if exists {
-						rowResp.Columns = append(rowResp.Columns,
-							&pb.ColumnResponse{ColumnVal: &pb.ColumnResponse_Int64Val{Int64Val: value}})
+					if field.Keys() {
+						value, exists, err := field.StringValue(col)
+						if err != nil {
+							return errors.Wrap(err, "getting string field value for column")
+						} else if exists {
+							rowResp.Columns = append(rowResp.Columns,
+								&pb.ColumnResponse{ColumnVal: &pb.ColumnResponse_StringVal{StringVal: value}})
+						} else {
+							rowResp.Columns = append(rowResp.Columns,
+								&pb.ColumnResponse{ColumnVal: nil})
+						}
 					} else {
-						rowResp.Columns = append(rowResp.Columns,
-							&pb.ColumnResponse{ColumnVal: nil})
+						value, exists, err := field.Value(col)
+						if err != nil {
+							return errors.Wrap(err, "getting int field value for column")
+						} else if exists {
+							rowResp.Columns = append(rowResp.Columns,
+								&pb.ColumnResponse{ColumnVal: &pb.ColumnResponse_Int64Val{Int64Val: value}})
+						} else {
+							rowResp.Columns = append(rowResp.Columns,
+								&pb.ColumnResponse{ColumnVal: nil})
+						}
 					}
 
 				case "decimal":
@@ -306,10 +331,19 @@ func (h grpcHandler) Inspect(req *pb.InspectRequest, stream pb.Pilosa_InspectSer
 		}
 
 	} else {
-		keys, ok := req.Columns.Type.(*pb.IdsOrKeys_Keys)
-		if !ok {
+		var cols []string
+
+		switch keys := req.Columns.Type.(type) {
+		case *pb.IdsOrKeys_Ids:
+			// The default behavior (in api/client/grpc.go) is to
+			// send an empty set of Ids even if the index supports
+			// keys, so in that case we just need to ignore it.
+		case *pb.IdsOrKeys_Keys:
+			cols = keys.Keys.Vals
+		default:
 			return errToStatusError(errors.New("invalid key columns"))
 		}
+
 		ci := []*pb.ColumnInfo{
 			{Name: "_id", Datatype: "string"},
 		}
@@ -319,7 +353,6 @@ func (h grpcHandler) Inspect(req *pb.InspectRequest, stream pb.Pilosa_InspectSer
 
 		// If Columns is empty, then get the _exists list (via All()),
 		// from the index and loop over that instead.
-		cols := keys.Keys.Vals
 		if len(cols) > 0 {
 			// Apply limit/offset to the provided columns.
 			if int(offset) >= len(cols) {
@@ -426,16 +459,30 @@ func (h grpcHandler) Inspect(req *pb.InspectRequest, stream pb.Pilosa_InspectSer
 						return errors.Wrap(err, "translating column key")
 					}
 
-					value, exists, err := field.Value(id)
-					if err != nil {
-						return errors.Wrap(err, "getting int field value for column")
-					} else if exists {
-						rowResp.Columns = append(rowResp.Columns,
-							&pb.ColumnResponse{ColumnVal: &pb.ColumnResponse_Int64Val{Int64Val: value}})
+					if field.Keys() {
+						value, exists, err := field.StringValue(id)
+						if err != nil {
+							return errors.Wrap(err, "getting string field value for column")
+						} else if exists {
+							rowResp.Columns = append(rowResp.Columns,
+								&pb.ColumnResponse{ColumnVal: &pb.ColumnResponse_StringVal{StringVal: value}})
+						} else {
+							rowResp.Columns = append(rowResp.Columns,
+								&pb.ColumnResponse{ColumnVal: nil})
+						}
 					} else {
-						rowResp.Columns = append(rowResp.Columns,
-							&pb.ColumnResponse{ColumnVal: nil})
+						value, exists, err := field.Value(id)
+						if err != nil {
+							return errors.Wrap(err, "getting int field value for column")
+						} else if exists {
+							rowResp.Columns = append(rowResp.Columns,
+								&pb.ColumnResponse{ColumnVal: &pb.ColumnResponse_Int64Val{Int64Val: value}})
+						} else {
+							rowResp.Columns = append(rowResp.Columns,
+								&pb.ColumnResponse{ColumnVal: nil})
+						}
 					}
+
 				case "decimal":
 					// Translate column key.
 					id, err := h.api.TranslateIndexKey(context.Background(), index.Name(), col)