scriptoriumadmin/featurebase
1
0
Fork 0
mirror of https://github.com/featurebasedb/featurebase.git synced 2026-09-07 09:05:55 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Change Ttl to TTL (#2038)

Browse source 
* Change Ttl to TTL

Following go convention, acronyms should have a consistent case.
See
[Initialisms](https://github.com/golang/go/wiki/CodeReviewComments#initialisms)

This commit changes some public-facing methods, so any code importing
this package and using these methods will need to be updated.

* rewrite Ttl -> TTL

Co-authored-by: reesporte <reesedporter@gmail.com>
This commit is contained in:
Travis Turner 2022-04-27 11:20:39 -05:00 • committed by GitHub
parent eba7927b56
commit 7ccc845aac
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
17 changed files with 503 additions and 270 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
client/client.go
View file

@ -1671,7 +1671,7 @@ type SchemaOptions struct {
CacheType string `json:"cacheType"`
CacheSize uint `json:"cacheSize"`
TimeQuantum string `json:"timeQuantum"`
Ttl time.Duration `json:"ttl"`
TTL time.Duration `json:"ttl"`
Min pql.Decimal `json:"min"`
Max pql.Decimal `json:"max"`
Scale int64 `json:"scale"`
@ -1696,7 +1696,7 @@ func (so SchemaOptions) asFieldOptions() *FieldOptions {
cacheSize: int(so.CacheSize),
cacheType: CacheType(so.CacheType),
timeQuantum: TimeQuantum(so.TimeQuantum),
ttl: so.Ttl,
ttl: so.TTL,
min: so.Min,
max: so.Max,
scale: so.Scale,

6
client/orm.go
View file

@ -752,8 +752,8 @@ func (fo FieldOptions) TimeQuantum() TimeQuantum {
return fo.timeQuantum
}
// Ttl returns the configured ttl for a time field.
func (fo FieldOptions) Ttl() time.Duration {
// TTL returns the configured ttl for a time field.
func (fo FieldOptions) TTL() time.Duration {
return fo.ttl
}
@ -920,7 +920,7 @@ func OptFieldTypeTime(quantum TimeQuantum, opts ...bool) FieldOption {
}
}
func OptFieldTtl(dur time.Duration) FieldOption {
func OptFieldTTL(dur time.Duration) FieldOption {
return func(options *FieldOptions) {
options.ttl = dur
}

8
client/orm_test.go
View file

@ -1026,8 +1026,8 @@ func TestORM(t *testing.T) {
0)
})
t.Run("TtlOptions", func(t *testing.T) {
field := sampleIndex.Field("ttl-field", OptFieldTypeTime(TimeQuantumDayHour, true), OptFieldTtl(0))
t.Run("TTLOptions", func(t *testing.T) {
field := sampleIndex.Field("ttl-field", OptFieldTypeTime(TimeQuantumDayHour, true), OptFieldTTL(0))
if true != field.Opts().NoStandardView() {
t.Fatalf("field noStandardView %v != %v", true, field.Opts().NoStandardView())
}
@ -1222,8 +1222,8 @@ func compareFieldOptions(t *testing.T, opts *FieldOptions, fieldType FieldType,
if timeUnit != opts.TimeUnit() {
t.Fatalf("%s != %s", timeUnit, opts.TimeUnit())
}
if ttl != opts.Ttl() {
t.Fatalf("%s != %s", ttl, opts.Ttl())
if ttl != opts.TTL() {
t.Fatalf("%s != %s", ttl, opts.TTL())
}
}

2
cmd/import.go
View file

@ -46,7 +46,7 @@ omitted. If it is present then its format should be YYYY-MM-DDTHH:MM.
flags.StringVar(&Importer.FieldOptions.CacheType, "field-cache-type", pilosa.CacheTypeRanked, "Specify the cache type for a set field on creation. One of: none, lru, ranked")
flags.Uint32Var(&Importer.FieldOptions.CacheSize, "field-cache-size", 50000, "Specify the cache size for a set field on creation")
flags.Var(&Importer.FieldOptions.TimeQuantum, "field-time-quantum", "Specify the time quantum for a time field on creation. One of: D, DH, H, M, MD, MDH, Y, YM, YMD, YMDH")
flags.DurationVarP(&Importer.FieldOptions.Ttl, "time-to-live", "t", 0, "Specify the time to live for views created by time quantum. Supported time unit: \"s\", \"m\", \"h\"") // \"ns\", \"us\" (or \"µs\"), \"ms\" also supported but ommitted for simplicity
flags.DurationVarP(&Importer.FieldOptions.TTL, "time-to-live", "t", 0, "Specify the time to live for views created by time quantum. Supported time unit: \"s\", \"m\", \"h\"") // \"ns\", \"us\" (or \"µs\"), \"ms\" also supported but ommitted for simplicity
flags.IntVarP(&Importer.BufferSize, "buffer-size", "s", 10000000, "Number of bits to buffer/sort before importing.")
flags.BoolVarP(&Importer.Sort, "sort", "", false, "Enables sorting before import.")
flags.BoolVarP(&Importer.CreateSchema, "create", "e", false, "Create the schema if it does not exist before import.")

6
encoding/proto/proto.go
View file

@ -669,7 +669,7 @@ func (s Serializer) encodeFieldOptions(o *pilosa.FieldOptions) *pb.FieldOptions
Scale: o.Scale,
BitDepth: uint64(o.BitDepth),
TimeQuantum: string(o.TimeQuantum),
Ttl: o.Ttl.String(),
TTL: o.TTL.String(),
TimeUnit: string(o.TimeUnit),
Keys: o.Keys,
ForeignIndex: o.ForeignIndex,
@ -1073,11 +1073,11 @@ func (s Serializer) decodeFieldOptions(options *pb.FieldOptions, m *pilosa.Field
m.Scale = options.Scale
m.BitDepth = uint64(options.BitDepth)
m.TimeQuantum = pilosa.TimeQuantum(options.TimeQuantum)
ttlValue, err := time.ParseDuration(options.Ttl)
ttlValue, err := time.ParseDuration(options.TTL)
if err != nil {
ttlValue = 0
}
m.Ttl = ttlValue
m.TTL = ttlValue
m.TimeUnit = options.TimeUnit
m.Keys = options.Keys
m.ForeignIndex = options.ForeignIndex

22
field.go
View file

@ -303,7 +303,7 @@ func OptFieldTypeTime(timeQuantum TimeQuantum, ttl string, opt ...bool) FieldOpt
if err != nil {
return errors.Errorf("cannot parse ttl: %s", ttl)
}
fo.Ttl = ttlParsed
fo.TTL = ttlParsed
fo.NoStandardView = len(opt) >= 1 && opt[0]
return nil
}
@ -685,9 +685,9 @@ func (f *Field) ForeignIndex() string {
return f.options.ForeignIndex
}
// Ttl returns the ttl of the field.
func (f *Field) Ttl() time.Duration {
return f.options.Ttl
// TTL returns the ttl of the field.
func (f *Field) TTL() time.Duration {
return f.options.TTL
}
func (f *Field) bitDepth() (uint64, error) {
@ -779,7 +779,7 @@ func (f *Field) applyOptions(opt FieldOptions) error {
f.options.Base = 0
f.options.BitDepth = 0
f.options.TimeQuantum = ""
f.options.Ttl = 0
f.options.TTL = 0
f.options.Keys = opt.Keys
f.options.ForeignIndex = opt.ForeignIndex
case FieldTypeInt, FieldTypeDecimal, FieldTypeTimestamp:
@ -793,7 +793,7 @@ func (f *Field) applyOptions(opt FieldOptions) error {
f.options.BitDepth = opt.BitDepth
f.options.TimeUnit = opt.TimeUnit
f.options.TimeQuantum = ""
f.options.Ttl = 0
f.options.TTL = 0
f.options.Keys = opt.Keys
f.options.ForeignIndex = opt.ForeignIndex
@ -827,7 +827,7 @@ func (f *Field) applyOptions(opt FieldOptions) error {
return ErrInvalidTimeQuantum
}
f.options.TimeQuantum = opt.TimeQuantum
f.options.Ttl = opt.Ttl
f.options.TTL = opt.TTL
f.options.ForeignIndex = opt.ForeignIndex
case FieldTypeBool:
f.options.Type = FieldTypeBool
@ -838,7 +838,7 @@ func (f *Field) applyOptions(opt FieldOptions) error {
f.options.Base = 0
f.options.BitDepth = 0
f.options.TimeQuantum = ""
f.options.Ttl = 0
f.options.TTL = 0
f.options.Keys = false
f.options.ForeignIndex = ""
default:
@ -1943,7 +1943,7 @@ type FieldOptions struct {
TimeUnit string `json:"timeUnit,omitempty"`
TimeQuantum TimeQuantum `json:"timeQuantum,omitempty"`
ForeignIndex string `json:"foreignIndex"`
Ttl time.Duration `json:"ttl,omitempty"`
TTL time.Duration `json:"ttl,omitempty"`
}
// newFieldOptions returns a new instance of FieldOptions
@ -2062,13 +2062,13 @@ func (o *FieldOptions) MarshalJSON() ([]byte, error) {
TimeQuantum TimeQuantum `json:"timeQuantum"`
Keys bool `json:"keys"`
NoStandardView bool `json:"noStandardView"`
Ttl time.Duration `json:"Ttl"`
TTL time.Duration `json:"ttl"`
}{
o.Type,
o.TimeQuantum,
o.Keys,
o.NoStandardView,
o.Ttl,
o.TTL,
})
case FieldTypeMutex:
return json.Marshal(struct {

2
field_test.go
View file

@ -280,7 +280,7 @@ func TestFieldInfoMarshal(t *testing.T) {
Options: pilosa.FieldOptions{Base: 0, BitDepth: 0x0, Min: pql.Decimal{Value: -4294967296,
Scale: 0}, Max: pql.Decimal{Value: 4294967296, Scale: 0}, Scale: 0, Keys: false,
NoStandardView: false, CacheType: "", Type: "timestamp", TimeUnit: "s",
TimeQuantum: "", ForeignIndex: "", Ttl: 0}, Cardinality: (*uint64)(nil)}
TimeQuantum: "", ForeignIndex: "", TTL: 0}, Cardinality: (*uint64)(nil)}
a, err := json.Marshal(f)
if err != nil {
t.Fatalf("unexpected error marshalling index info, %v", err)

4
hack.go
View file

@ -52,11 +52,11 @@ func UnmarshalFieldOptions(name string, createdAt int64, buf []byte) (*FieldInfo
fi.Options.Base = pbi.Base
fi.Options.BitDepth = pbi.BitDepth
fi.Options.TimeQuantum = TimeQuantum(pbi.TimeQuantum)
ttlValue, err := time.ParseDuration(pbi.Ttl)
ttlValue, err := time.ParseDuration(pbi.TTL)
if err != nil {
ttlValue = 0
}
fi.Options.Ttl = ttlValue
fi.Options.TTL = ttlValue
fi.Options.Keys = pbi.Keys
fi.Options.NoStandardView = pbi.NoStandardView

22
http_handler.go
View file

@ -1625,8 +1625,8 @@ func fieldOptionsToFunctionalOpts(opt fieldOptions) []FieldOption {
}
fos = append(fos, OptFieldTypeTimestamp(opt.Epoch.UTC(), *opt.TimeUnit))
case FieldTypeTime:
if opt.Ttl != nil {
fos = append(fos, OptFieldTypeTime(*opt.TimeQuantum, *opt.Ttl, opt.NoStandardView))
if opt.TTL != nil {
fos = append(fos, OptFieldTypeTime(*opt.TimeQuantum, *opt.TTL, opt.NoStandardView))
} else {
fos = append(fos, OptFieldTypeTime(*opt.TimeQuantum, "0", opt.NoStandardView))
}
@ -1755,7 +1755,7 @@ type fieldOptionSpec struct {
Epoch *time.Time `json:"epoch"`
Unit *string `json:"unit"`
TimeQuantum *string `json:"time-quantum"`
Ttl *string `json:"ttl"`
TTL *string `json:"ttl"`
}
func fieldSpecToFieldOption(fSpec fieldSpec) fieldOptions {
@ -1789,7 +1789,7 @@ func fieldSpecToFieldOption(fSpec fieldSpec) fieldOptions {
timeQuantumVal := TimeQuantum(*fSpec.FieldOptions.TimeQuantum)
opt.TimeQuantum = &timeQuantumVal
}
opt.Ttl = fSpec.FieldOptions.Ttl
opt.TTL = fSpec.FieldOptions.TTL
return opt
}
@ -1886,7 +1886,7 @@ type fieldOptions struct {
Keys *bool `json:"keys,omitempty"`
NoStandardView bool `json:"noStandardView,omitempty"`
ForeignIndex *string `json:"foreignIndex,omitempty"`
Ttl *string `json:"ttl,omitempty"`
TTL *string `json:"ttl,omitempty"`
}
func (o *fieldOptions) validate() error {
@ -1914,7 +1914,7 @@ func (o *fieldOptions) validate() error {
return NewBadRequestError(errors.New("max does not apply to field type set"))
} else if o.TimeQuantum != nil {
return NewBadRequestError(errors.New("timeQuantum does not apply to field type set"))
} else if o.Ttl != nil {
} else if o.TTL != nil {
return NewBadRequestError(errors.New("ttl does not apply to field type set"))
}
case FieldTypeInt:
@ -1924,7 +1924,7 @@ func (o *fieldOptions) validate() error {
return NewBadRequestError(errors.New("cacheSize does not apply to field type int"))
} else if o.TimeQuantum != nil {
return NewBadRequestError(errors.New("timeQuantum does not apply to field type int"))
} else if o.Ttl != nil {
} else if o.TTL != nil {
return NewBadRequestError(errors.New("ttl does not apply to field type int"))
}
case FieldTypeDecimal:
@ -1936,7 +1936,7 @@ func (o *fieldOptions) validate() error {
return NewBadRequestError(errors.New("cacheSize does not apply to field type int"))
} else if o.TimeQuantum != nil {
return NewBadRequestError(errors.New("timeQuantum does not apply to field type int"))
} else if o.Ttl != nil {
} else if o.TTL != nil {
return NewBadRequestError(errors.New("ttl does not apply to field type int"))
} else if o.ForeignIndex != nil && o.Type == FieldTypeDecimal {
return NewBadRequestError(errors.New("decimal field cannot be a foreign key"))
@ -1952,7 +1952,7 @@ func (o *fieldOptions) validate() error {
return NewBadRequestError(errors.New("cacheSize does not apply to field type timestamp"))
} else if o.TimeQuantum != nil {
return NewBadRequestError(errors.New("timeQuantum does not apply to field type timestamp"))
} else if o.Ttl != nil {
} else if o.TTL != nil {
return NewBadRequestError(errors.New("ttl does not apply to field type timestamp"))
} else if o.ForeignIndex != nil {
return NewBadRequestError(errors.New("timestamp field cannot be a foreign key"))
@ -1982,7 +1982,7 @@ func (o *fieldOptions) validate() error {
return NewBadRequestError(errors.New("max does not apply to field type mutex"))
} else if o.TimeQuantum != nil {
return NewBadRequestError(errors.New("timeQuantum does not apply to field type mutex"))
} else if o.Ttl != nil {
} else if o.TTL != nil {
return NewBadRequestError(errors.New("ttl does not apply to field type mutex"))
}
case FieldTypeBool:
@ -1998,7 +1998,7 @@ func (o *fieldOptions) validate() error {
return NewBadRequestError(errors.New("timeQuantum does not apply to field type bool"))
} else if o.Keys != nil {
return NewBadRequestError(errors.New("keys does not apply to field type bool"))
} else if o.Ttl != nil {
} else if o.TTL != nil {
return NewBadRequestError(errors.New("ttl does not apply to field type bool"))
} else if o.ForeignIndex != nil {
return NewBadRequestError(errors.New("bool field cannot be a foreign key"))

18
http_handler_test.go
View file

@ -172,7 +172,7 @@ func TestIngestSchemaHandler(t *testing.T) {
}
}
func TestPostFieldWithTtl(t *testing.T) {
func TestPostFieldWithTTL(t *testing.T) {
c := test.MustRunCluster(t, 1)
defer c.Close()
@ -191,33 +191,33 @@ func TestPostFieldWithTtl(t *testing.T) {
t.Errorf("invalid status: %d, body=%s", resp.StatusCode, resp.Body)
}
postFieldTtlUrl := fmt.Sprintf("%s/index/example/field/with_ttl", m.URL())
postFieldTTLUrl := fmt.Sprintf("%s/index/example/field/with_ttl", m.URL())
// Create new field with ttl but in invalid format
fieldOptionInvalidTtl := `
fieldOptionInvalidTTL := `
{ "options": {"timeQuantum":"YMDH","type":"time","ttl":"24hour" }}
`
respField := test.Do(t, "POST", postFieldTtlUrl, string(fieldOptionInvalidTtl))
respField := test.Do(t, "POST", postFieldTTLUrl, string(fieldOptionInvalidTTL))
if (respField.StatusCode != gohttp.StatusBadRequest) &&
(respField.Body != "applying option: cannot parse ttl: 24hour") {
t.Errorf("expected ttl parse error, got status: %d, body=%s", respField.StatusCode, respField.Body)
}
// Create new field with ttl in invalid format
fieldOptionValidTtl := `
fieldOptionValidTTL := `
{ "options": {"timeQuantum":"YMDH","type":"time","ttl":"24h" }}
`
respField = test.Do(t, "POST", postFieldTtlUrl, string(fieldOptionValidTtl))
respField = test.Do(t, "POST", postFieldTTLUrl, string(fieldOptionValidTTL))
if resp.StatusCode != gohttp.StatusOK {
t.Errorf("creating field with ttl, got status: %d, body=%s", respField.StatusCode, respField.Body)
}
// Create new field without ttl
postFieldNoTtlUrl := fmt.Sprintf("%s/index/example/field/no_ttl", m.URL())
fieldOptionNoTtl := `
postFieldNoTTLUrl := fmt.Sprintf("%s/index/example/field/no_ttl", m.URL())
fieldOptionNoTTL := `
{ "options": {"timeQuantum":"YMDH","type":"time" }}
`
respField = test.Do(t, "POST", postFieldNoTtlUrl, string(fieldOptionNoTtl))
respField = test.Do(t, "POST", postFieldNoTTLUrl, string(fieldOptionNoTTL))
if resp.StatusCode != gohttp.StatusOK {
t.Errorf("creating field without ttl, status: %d, body=%s", respField.StatusCode, respField.Body)
}

4
internal_client.go
View file

@ -1093,8 +1093,8 @@ func (c *InternalClient) CreateFieldWithOptions(ctx context.Context, index, fiel
fieldOpt.Max = &opt.Max
case FieldTypeTime:
fieldOpt.TimeQuantum = &opt.TimeQuantum
ttlString := opt.Ttl.String()
fieldOpt.Ttl = &ttlString
ttlString := opt.TTL.String()
fieldOpt.TTL = &ttlString
case FieldTypeBool:
// pass
case FieldTypeDecimal:

21
internal_client_test.go
View file

@ -7,7 +7,6 @@ import (
"context"
"encoding/hex"
"fmt"
"net/http"
gohttp "net/http"
"reflect"
"strings"
@ -1199,21 +1198,21 @@ func TestClient_CreateTimeField(t *testing.T) {
if err != nil {
t.Fatalf("getting field: %v", err)
}
if fld.Ttl() != 0 {
t.Fatalf("expected Ttl to be 0, got: %+v", fld.Options().Ttl.String())
if fld.TTL() != 0 {
t.Fatalf("expected TTL to be 0, got: %+v", fld.Options().TTL.String())
}
fieldTtl := "field_ttl"
err = c.CreateFieldWithOptions(context.Background(), index, fieldTtl, pilosa.FieldOptions{Type: pilosa.FieldTypeTime, TimeQuantum: "YMDH", Ttl: time.Hour})
fieldTTL := "field_ttl"
err = c.CreateFieldWithOptions(context.Background(), index, fieldTTL, pilosa.FieldOptions{Type: pilosa.FieldTypeTime, TimeQuantum: "YMDH", TTL: time.Hour})
if err != nil {
t.Fatalf("creating field: %v", err)
}
fldTtl, err := cmd.API.Field(context.Background(), index, fieldTtl)
fldTTL, err := cmd.API.Field(context.Background(), index, fieldTTL)
if err != nil {
t.Fatalf("getting field: %v", err)
}
if fldTtl.Ttl() != time.Hour {
t.Fatalf("expected Ttl 1 hour, got: %+v", fldTtl.Ttl().String())
if fldTTL.TTL() != time.Hour {
t.Fatalf("expected TTL 1 hour, got: %+v", fldTTL.TTL().String())
}
}
@ -1573,7 +1572,7 @@ func TestClient_ImportRoaringExists(t *testing.T) {
func TestAddAuthToken(t *testing.T) {
t.Run("none", func(t *testing.T) {
req, err := http.NewRequest("GET", "dontmatternone", strings.NewReader("this doesn't matter"))
req, err := gohttp.NewRequest("GET", "dontmatternone", strings.NewReader("this doesn't matter"))
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
@ -1583,7 +1582,7 @@ func TestAddAuthToken(t *testing.T) {
}
})
t.Run("userinfo", func(t *testing.T) {
req, err := http.NewRequest("GET", "dontmatternone", strings.NewReader("this doesn't matter"))
req, err := gohttp.NewRequest("GET", "dontmatternone", strings.NewReader("this doesn't matter"))
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
@ -1594,7 +1593,7 @@ func TestAddAuthToken(t *testing.T) {
}
})
t.Run("token", func(t *testing.T) {
req, err := http.NewRequest("GET", "dontmatternone", strings.NewReader("this doesn't matter"))
req, err := gohttp.NewRequest("GET", "dontmatternone", strings.NewReader("this doesn't matter"))
if err != nil {
t.Fatalf("unexpected error: %v", err)
}

451
pb/private.pb.go
View file

@ -93,7 +93,7 @@ type FieldOptions struct {
Min *Decimal `protobuf:"bytes,17,opt,name=Min,proto3" json:"Min,omitempty"`
Max *Decimal `protobuf:"bytes,18,opt,name=Max,proto3" json:"Max,omitempty"`
TimeUnit string `protobuf:"bytes,19,opt,name=TimeUnit,proto3" json:"TimeUnit,omitempty"`
Ttl string `protobuf:"bytes,20,opt,name=Ttl,proto3" json:"Ttl,omitempty"`
TTL string `protobuf:"bytes,20,opt,name=TTL,proto3" json:"TTL,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -237,9 +237,9 @@ func (m *FieldOptions) GetTimeUnit() string {
return ""
}
func (m *FieldOptions) GetTtl() string {
func (m *FieldOptions) GetTTL() string {
if m != nil {
return m.Ttl
return m.TTL
}
return ""
}
@ -2767,111 +2767,111 @@ func init() {
func init() { proto.RegisterFile("private.proto", fileDescriptor_d2a91b51c7bdc125) }
var fileDescriptor_d2a91b51c7bdc125 = []byte{
// 1650 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xcf, 0x72, 0x1b, 0x45,
0x13, 0xff, 0x76, 0x57, 0xb2, 0xa4, 0x96, 0x65, 0xcb, 0x13, 0x7f, 0xf9, 0xd6, 0x4e, 0x3e, 0x97,
0x3c, 0x50, 0x89, 0x70, 0x15, 0xa6, 0x70, 0x0e, 0xa1, 0xe0, 0x12, 0x5b, 0x72, 0x82, 0x08, 0x4e,
0x9c, 0xb1, 0xe3, 0x23, 0xd4, 0x58, 0x9a, 0xb2, 0xb7, 0xbc, 0xda, 0x15, 0xbb, 0x2b, 0x47, 0xca,
0x81, 0x2a, 0x28, 0x28, 0xb8, 0x70, 0xe7, 0xc4, 0x5b, 0xf0, 0x02, 0x9c, 0xb8, 0x50, 0xc5, 0x23,
0x50, 0xe1, 0x45, 0xa8, 0xe9, 0x99, 0xd9, 0x5d, 0x29, 0x72, 0x04, 0x2e, 0x6e, 0xdb, 0xbf, 0xee,
0xe9, 0x7f, 0xd3, 0xd3, 0xd3, 0xb3, 0x50, 0x1b, 0x44, 0xde, 0x25, 0x4f, 0xc4, 0xf6, 0x20, 0x0a,
0x93, 0x90, 0xd8, 0x83, 0xd3, 0xf5, 0xc5, 0xc1, 0xf0, 0xd4, 0xf7, 0xba, 0x0a, 0xa1, 0x8f, 0xa0,
0xd2, 0x09, 0x7a, 0x62, 0x74, 0x20, 0x12, 0x4e, 0x08, 0x14, 0x1e, 0x8b, 0x71, 0xec, 0x3a, 0x0d,
0xab, 0x59, 0x66, 0xf8, 0x4d, 0xee, 0xc0, 0xd2, 0x71, 0xc4, 0xbb, 0x17, 0xfb, 0x23, 0x2f, 0x4e,
0x44, 0xd0, 0x15, 0x6e, 0x01, 0xb9, 0x53, 0x28, 0xfd, 0xc5, 0x81, 0xc5, 0x87, 0x9e, 0xf0, 0x7b,
0x4f, 0x07, 0x89, 0x17, 0x06, 0xb1, 0x54, 0x76, 0x3c, 0x1e, 0x08, 0xb7, 0xdc, 0xb0, 0x9a, 0x15,
0x86, 0xdf, 0xe4, 0x36, 0x54, 0x5a, 0xbc, 0x7b, 0x2e, 0x90, 0xe1, 0x20, 0x23, 0x03, 0x52, 0xee,
0x91, 0xf7, 0x52, 0x59, 0xa9, 0xb1, 0x0c, 0x20, 0x0d, 0xa8, 0x1e, 0x7b, 0x7d, 0xf1, 0x6c, 0xc8,
0x83, 0x64, 0xd8, 0x77, 0x8b, 0xb8, 0x3a, 0x0f, 0x91, 0x9b, 0xb0, 0xf0, 0xd4, 0xef, 0x1d, 0x78,
0x81, 0x5b, 0x69, 0x58, 0x4d, 0x87, 0x69, 0xca, 0xe0, 0x7c, 0xe4, 0x42, 0x86, 0xf3, 0x51, 0x1a,
0x6e, 0x75, 0x32, 0xdc, 0x27, 0xe1, 0x51, 0xc2, 0x83, 0x1e, 0x8f, 0x7a, 0x27, 0x9e, 0x78, 0xe1,
0x2e, 0xaa, 0x70, 0x27, 0x51, 0xb9, 0x76, 0x8f, 0xc7, 0xc2, 0xad, 0xa1, 0x46, 0xfc, 0x26, 0xeb,
0x50, 0xde, 0xf3, 0x92, 0xb6, 0x18, 0x24, 0xe7, 0xee, 0x52, 0xc3, 0x6a, 0x16, 0x58, 0x4a, 0x93,
0x55, 0x28, 0x1e, 0x75, 0xb9, 0x2f, 0xdc, 0x65, 0x5c, 0xa0, 0x08, 0x42, 0x61, 0xf1, 0x61, 0x18,
0x09, 0xef, 0x2c, 0xc0, 0x4d, 0x70, 0xeb, 0x18, 0xd4, 0x04, 0x46, 0xfe, 0x0f, 0x8e, 0x0c, 0x69,
0xa5, 0x61, 0x35, 0xab, 0x3b, 0xd5, 0xed, 0xc1, 0xe9, 0x76, 0x5b, 0x74, 0xbd, 0x3e, 0xf7, 0x99,
0xc4, 0x91, 0xcd, 0x47, 0x2e, 0x99, 0xc5, 0xe6, 0x23, 0xe9, 0x93, 0x4c, 0xd1, 0xf3, 0xc0, 0x4b,
0xdc, 0x1b, 0xa8, 0x3d, 0xa5, 0x49, 0x1d, 0x9c, 0xe3, 0xc4, 0x77, 0x57, 0x11, 0x96, 0x9f, 0x94,
0xc2, 0x52, 0xa7, 0x3f, 0x08, 0xa3, 0x84, 0x89, 0x78, 0x10, 0x06, 0xb1, 0x90, 0x32, 0xfb, 0x51,
0xe4, 0x5a, 0x4a, 0x66, 0x3f, 0x8a, 0xe8, 0x97, 0x50, 0xdf, 0xf3, 0xc3, 0xee, 0x45, 0x9b, 0x27,
0x9c, 0x89, 0x2f, 0x86, 0x22, 0x4e, 0x64, 0x74, 0x2a, 0x00, 0x25, 0xa7, 0x08, 0x89, 0x62, 0x45,
0xb8, 0xb6, 0x42, 0x91, 0x90, 0x99, 0xc3, 0xbc, 0xaa, 0x0d, 0xc4, 0x6f, 0xcc, 0xce, 0x39, 0x8f,
0x7a, 0xb8, 0xeb, 0x05, 0xa6, 0x08, 0x89, 0xa2, 0x25, 0xac, 0x94, 0x02, 0x53, 0x04, 0xed, 0xc0,
0x4a, 0xce, 0xbe, 0x76, 0xf3, 0x26, 0x2c, 0xb0, 0xf0, 0x45, 0xa7, 0x1d, 0xbb, 0x56, 0xc3, 0x69,
0x16, 0x98, 0xa6, 0xb0, 0xa4, 0x42, 0x7f, 0xd8, 0x0f, 0x24, 0xcb, 0x46, 0x56, 0x06, 0xd0, 0x35,
0x28, 0x62, 0x7d, 0xc9, 0x28, 0xb3, 0xb5, 0xf2, 0x93, 0x7e, 0x65, 0x41, 0xe5, 0x80, 0x8f, 0xd0,
0x91, 0x98, 0xdc, 0x87, 0xb2, 0xd9, 0x7d, 0x14, 0xaa, 0xee, 0xdc, 0x92, 0x99, 0x4e, 0x05, 0xb6,
0x0d, 0x77, 0x3f, 0x48, 0xa2, 0x31, 0x4b, 0x85, 0xd7, 0x3f, 0x82, 0xda, 0x04, 0x4b, 0x5a, 0xba,
0x10, 0x63, 0x93, 0xcf, 0x0b, 0x31, 0x96, 0x51, 0x5e, 0x72, 0x7f, 0x28, 0x30, 0x4b, 0x05, 0xa6,
0x88, 0x0f, 0xed, 0x0f, 0x2c, 0x7a, 0x02, 0xa4, 0x15, 0x09, 0x9e, 0x08, 0x34, 0x72, 0x20, 0xe2,
0x98, 0x9f, 0x89, 0x79, 0xb9, 0x76, 0xf2, 0xb9, 0x4e, 0xf3, 0x6a, 0xe7, 0xf2, 0x4a, 0xb7, 0x80,
0xb4, 0x85, 0x2f, 0x12, 0xa1, 0x4f, 0xfe, 0x1b, 0xf4, 0xd2, 0x0b, 0xe3, 0xc3, 0x7c, 0x59, 0xb2,
0x09, 0x05, 0xd9, 0x46, 0xd0, 0x58, 0x75, 0xa7, 0x26, 0x33, 0x94, 0xf6, 0x16, 0x86, 0x2c, 0xdc,
0x0f, 0x54, 0xd7, 0xdb, 0x4d, 0xd0, 0x55, 0x87, 0x65, 0x00, 0xfd, 0xc6, 0x32, 0xd6, 0xd0, 0xfd,
0xbf, 0x19, 0xf1, 0x44, 0x75, 0xbd, 0xad, 0x7d, 0x70, 0xd0, 0x87, 0xba, 0xf4, 0x21, 0xdf, 0x95,
0x66, 0xb9, 0x51, 0x98, 0x76, 0xe3, 0x81, 0xc9, 0xcf, 0x75, 0xbd, 0xa0, 0x5d, 0xb8, 0xa5, 0x34,
0xec, 0x5e, 0x72, 0xcf, 0xe7, 0xa7, 0xfe, 0x3f, 0xda, 0xc2, 0x89, 0x80, 0x5c, 0x28, 0xe1, 0xda,
0x4e, 0x5b, 0x1f, 0x03, 0x43, 0xd2, 0x21, 0x64, 0x27, 0xea, 0x09, 0xef, 0x0b, 0xad, 0x0d, 0xbf,
0xd3, 0x3c, 0xd8, 0x6f, 0xcc, 0xc3, 0x2a, 0x14, 0xe5, 0xf9, 0x93, 0x1d, 0xdf, 0x91, 0x26, 0x91,
0x98, 0x93, 0x9d, 0x77, 0x61, 0xe1, 0xa8, 0x7b, 0x2e, 0xfa, 0x9c, 0xbc, 0x05, 0x25, 0xf4, 0x5c,
0xc4, 0xfa, 0x50, 0x54, 0xd2, 0x2d, 0x67, 0x86, 0x43, 0xbf, 0xb5, 0x74, 0xb0, 0x33, 0xdd, 0x9c,
0x30, 0x65, 0x4f, 0x99, 0x22, 0x77, 0xa1, 0xa4, 0xfd, 0xc5, 0x6e, 0xf1, 0x5a, 0x4d, 0x19, 0x2e,
0xd9, 0x84, 0x05, 0x8c, 0x2e, 0x76, 0x0b, 0x99, 0x23, 0x88, 0x30, 0xcd, 0xa0, 0xfb, 0xe0, 0x3c,
0x67, 0x1d, 0xd9, 0x28, 0xd0, 0x7b, 0xe3, 0x86, 0xa6, 0xa4, 0x73, 0x1f, 0x87, 0x71, 0xa2, 0x73,
0x8f, 0xdf, 0x12, 0x3b, 0x0c, 0x23, 0x55, 0xa7, 0x35, 0x86, 0xdf, 0xf4, 0x7b, 0x0b, 0x0a, 0x4f,
0xc2, 0x9e, 0x20, 0x4b, 0x60, 0x77, 0xda, 0x5a, 0x89, 0xdd, 0x69, 0x93, 0x35, 0xd4, 0xaf, 0xf3,
0x5d, 0x92, 0xf6, 0x9f, 0xb3, 0x0e, 0x43, 0x9b, 0xb7, 0xa1, 0xd2, 0x89, 0x0f, 0x23, 0xaf, 0xcf,
0xa3, 0xb1, 0xbe, 0x5b, 0x33, 0x00, 0xcf, 0x68, 0xc2, 0x13, 0x75, 0xe3, 0x55, 0x98, 0x22, 0xc8,
0x26, 0x94, 0x1e, 0xb1, 0xc3, 0x96, 0x54, 0x59, 0x9c, 0x54, 0x69, 0x70, 0xfa, 0x00, 0xea, 0xd2,
0x13, 0x94, 0x37, 0x95, 0x75, 0x13, 0x16, 0x24, 0x96, 0x7a, 0xa6, 0xa9, 0xcc, 0x88, 0x9d, 0x33,
0x42, 0x1f, 0x2a, 0x0d, 0xfb, 0x97, 0x22, 0x48, 0x72, 0xb5, 0x89, 0x34, 0x2a, 0xa8, 0x31, 0x45,
0x90, 0xdb, 0x2a, 0x6a, 0x1d, 0x5e, 0x59, 0xfa, 0x22, 0x69, 0x86, 0x28, 0x1d, 0x03, 0x18, 0x4f,
0x86, 0x71, 0x2a, 0x6b, 0xcd, 0x92, 0x25, 0xd4, 0x94, 0x8f, 0x3e, 0xa2, 0x20, 0xf9, 0x0a, 0x61,
0xa6, 0xb0, 0xde, 0xc9, 0x0a, 0x4b, 0xed, 0xe7, 0x72, 0xba, 0xef, 0xca, 0x46, 0x56, 0x5e, 0xe7,
0x50, 0xcd, 0xe1, 0x33, 0x6b, 0xec, 0x6e, 0x5a, 0x1c, 0x76, 0xa6, 0x0c, 0x11, 0xad, 0x4c, 0xb3,
0xe7, 0x34, 0x27, 0x0f, 0xaa, 0xb9, 0x45, 0x33, 0x2d, 0x35, 0x61, 0x79, 0xf2, 0xc0, 0x9b, 0x3b,
0x67, 0x1a, 0x9e, 0x63, 0xea, 0x3b, 0x0b, 0x6a, 0x2d, 0x7f, 0x18, 0x27, 0x22, 0x4a, 0x73, 0x5a,
0xd1, 0x40, 0xba, 0xb5, 0x19, 0x30, 0x7b, 0x77, 0xc9, 0x06, 0x14, 0x65, 0xc6, 0xd5, 0xe1, 0xce,
0x6f, 0x84, 0x82, 0x73, 0x3b, 0x51, 0xb8, 0x6a, 0x27, 0xe8, 0x09, 0x94, 0xf7, 0x8e, 0x3a, 0x8f,
0xa2, 0x70, 0x38, 0x98, 0x19, 0xb1, 0x19, 0xf2, 0xec, 0xdc, 0x90, 0x57, 0x57, 0x03, 0x8b, 0x8a,
0x0a, 0x67, 0x94, 0xba, 0x9a, 0x51, 0x0a, 0x1a, 0xe1, 0x23, 0x7a, 0x04, 0x2b, 0x2a, 0x5c, 0xd9,
0x71, 0xae, 0xd3, 0x16, 0xcd, 0x14, 0xe1, 0x64, 0x53, 0x84, 0x54, 0xaa, 0xba, 0xee, 0xbf, 0xa9,
0xf4, 0x37, 0x1b, 0x56, 0x98, 0x88, 0xbd, 0x97, 0xa2, 0x13, 0xc4, 0x49, 0x34, 0xec, 0xca, 0x8e,
0x23, 0xd7, 0x7f, 0x12, 0x9e, 0xea, 0xbd, 0x70, 0x98, 0x22, 0xde, 0x7c, 0x4a, 0x08, 0x85, 0x52,
0xbe, 0x09, 0xe4, 0x05, 0x0c, 0x83, 0x6c, 0x41, 0xe9, 0x28, 0x1c, 0x46, 0xdd, 0xb4, 0xf2, 0xb1,
0x73, 0x2b, 0xfb, 0x8a, 0xc1, 0x8c, 0x00, 0x79, 0x0c, 0xe4, 0x38, 0xe2, 0x41, 0xec, 0x73, 0xe9,
0x92, 0x59, 0x56, 0xce, 0xc6, 0x93, 0x1c, 0x77, 0x42, 0xc3, 0x8c, 0x65, 0x64, 0x3b, 0x7f, 0x84,
0xdd, 0x12, 0xfa, 0xb7, 0x64, 0xfc, 0xd3, 0xe7, 0x24, 0x7f, 0xc8, 0xef, 0x4f, 0x55, 0xa8, 0xbb,
0x80, 0x4b, 0x56, 0xe4, 0x92, 0x09, 0x06, 0x9b, 0x94, 0xa3, 0x5f, 0x5b, 0xb0, 0x98, 0xf7, 0x66,
0x4e, 0xbb, 0x48, 0xb7, 0xcf, 0x9e, 0x3f, 0xed, 0x98, 0xed, 0x2b, 0xcc, 0x9a, 0x2c, 0x8b, 0xf9,
0x09, 0x28, 0x84, 0xff, 0x5d, 0x91, 0x9c, 0x6b, 0xb9, 0xd3, 0x80, 0xea, 0x21, 0x8f, 0x12, 0x4f,
0x2a, 0xd3, 0xf7, 0x74, 0x91, 0xe5, 0x21, 0x2a, 0x60, 0xed, 0xb5, 0x22, 0x6a, 0x85, 0xfd, 0x81,
0xac, 0xd6, 0x6b, 0x15, 0x93, 0x6c, 0xd3, 0x51, 0x14, 0x46, 0x26, 0x03, 0x48, 0xd0, 0x3d, 0x28,
0x1f, 0x87, 0x83, 0xd0, 0x0f, 0xcf, 0xc6, 0x73, 0x5a, 0x86, 0x0b, 0x25, 0x75, 0x35, 0xa8, 0x16,
0x55, 0x61, 0x86, 0xa4, 0x37, 0x64, 0xbd, 0x77, 0xb9, 0xdf, 0x1d, 0xfa, 0x3c, 0x11, 0x38, 0x1f,
0x23, 0xf8, 0x69, 0xc8, 0x7b, 0xaa, 0x2b, 0xe8, 0xa3, 0x45, 0x3f, 0xd7, 0x05, 0xc8, 0x31, 0x9c,
0xdc, 0x15, 0xb4, 0x8b, 0x80, 0xb9, 0x82, 0x14, 0x45, 0xde, 0x87, 0x6a, 0x4e, 0x5a, 0x87, 0xb5,
0x9c, 0xd6, 0xa9, 0x82, 0x59, 0x5e, 0x86, 0xfe, 0x6c, 0x4d, 0xac, 0x79, 0xed, 0xce, 0xd5, 0xa6,
0x2e, 0x55, 0x92, 0xca, 0x4c, 0x53, 0x32, 0xf4, 0xfd, 0x51, 0xd7, 0x1f, 0xc6, 0x92, 0xa5, 0x2f,
0xdc, 0x14, 0x90, 0xa1, 0xcb, 0x27, 0x50, 0x38, 0x34, 0xc3, 0x8d, 0x21, 0xe5, 0x63, 0xa9, 0x2d,
0x78, 0xcf, 0xf7, 0x02, 0x81, 0xf5, 0xe2, 0xb0, 0x94, 0x26, 0x5b, 0xaa, 0xc7, 0x9a, 0x42, 0x5f,
0x9d, 0x72, 0x1c, 0x79, 0xaa, 0xf3, 0xc6, 0x94, 0x40, 0x7d, 0x9a, 0x45, 0x57, 0x81, 0xa8, 0x0a,
0xd8, 0x3d, 0x0d, 0x23, 0x73, 0xdb, 0xd2, 0x96, 0x69, 0x2e, 0x32, 0xfb, 0xf3, 0x2e, 0xf1, 0x2c,
0xb3, 0x76, 0x3e, 0xb3, 0xf4, 0x33, 0x58, 0xd2, 0xb3, 0x9d, 0x88, 0xb0, 0xa0, 0x65, 0x02, 0x98,
0xe8, 0x86, 0x72, 0x4c, 0x34, 0xaf, 0x9a, 0x0c, 0x90, 0x7a, 0x4e, 0xe4, 0x23, 0xc3, 0xdc, 0x4e,
0x9a, 0xc2, 0xd9, 0xc8, 0x3b, 0x0b, 0x44, 0x0f, 0x6f, 0x0c, 0x87, 0x69, 0x8a, 0xfe, 0x60, 0xc3,
0xaa, 0x1a, 0x3a, 0x83, 0x33, 0x11, 0x27, 0x99, 0x19, 0xf9, 0xb0, 0x1e, 0x60, 0xff, 0xd7, 0x8e,
0x2a, 0x4a, 0x3e, 0xa2, 0x5b, 0xbe, 0xe0, 0x51, 0xe6, 0x83, 0x32, 0x34, 0x85, 0xca, 0x73, 0x83,
0x88, 0xbe, 0x9e, 0xd5, 0x10, 0x9a, 0x87, 0xc8, 0x1e, 0x94, 0x75, 0x68, 0xa6, 0x21, 0xde, 0xc1,
0x5b, 0x6a, 0x86, 0x37, 0x66, 0xbe, 0x8d, 0xf5, 0x1b, 0xcc, 0x90, 0xeb, 0x4f, 0xa1, 0x36, 0xc1,
0x9a, 0xf1, 0x06, 0x6b, 0xe6, 0xdf, 0x60, 0xd5, 0x1d, 0x92, 0x1b, 0x97, 0xb5, 0xf6, 0xfc, 0xbb,
0xac, 0x05, 0xff, 0x9d, 0xe5, 0x40, 0x4c, 0xb6, 0xc0, 0x91, 0x8e, 0xaa, 0x61, 0xd8, 0xbd, 0xca,
0x51, 0x26, 0x85, 0xe8, 0x4f, 0x96, 0x4e, 0xaa, 0xd0, 0x7c, 0xf3, 0x96, 0xbe, 0x97, 0x57, 0xb2,
0x99, 0x2a, 0x99, 0x12, 0xdb, 0x4e, 0x03, 0x95, 0xd2, 0xeb, 0xcf, 0xa0, 0x3c, 0x2b, 0xbc, 0x82,
0x0a, 0xef, 0xbd, 0xc9, 0xf0, 0xd6, 0xae, 0xf2, 0x2c, 0xce, 0x45, 0xb9, 0x57, 0xff, 0xf5, 0xd5,
0x86, 0xf5, 0xfb, 0xab, 0x0d, 0xeb, 0x8f, 0x57, 0x1b, 0xd6, 0x8f, 0x7f, 0x6e, 0xfc, 0xe7, 0x74,
0x01, 0x7f, 0x19, 0xdd, 0xfb, 0x2b, 0x00, 0x00, 0xff, 0xff, 0xcf, 0xdb, 0x63, 0xcd, 0x55, 0x12,
0x00, 0x00,
// 1652 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0x4f, 0x6f, 0xdb, 0xc6,
0x12, 0x7f, 0x24, 0x25, 0x4b, 0x1a, 0x59, 0xb6, 0xbc, 0xf1, 0xcb, 0xa3, 0x9d, 0x3c, 0x43, 0xde,
0xf7, 0x90, 0xa8, 0x06, 0xea, 0xa2, 0xce, 0x21, 0x45, 0x7b, 0x89, 0x2d, 0x39, 0xa9, 0x9a, 0x38,
0x71, 0xd6, 0x8e, 0x8f, 0x2d, 0xd6, 0xd2, 0xc2, 0x26, 0x4c, 0x91, 0x2a, 0x49, 0x39, 0x52, 0x0e,
0x05, 0x5a, 0xb4, 0x68, 0x2f, 0xbd, 0xf7, 0xd4, 0x6f, 0xd1, 0x2f, 0xd0, 0x53, 0x2f, 0x05, 0xfa,
0x11, 0x8a, 0xf4, 0x8b, 0x14, 0x3b, 0xbb, 0x4b, 0x52, 0x8a, 0x1c, 0xb5, 0x46, 0x6f, 0x9c, 0xdf,
0xcc, 0xce, 0xbf, 0x9d, 0x9d, 0x9d, 0x25, 0xd4, 0x06, 0x91, 0x77, 0xc9, 0x13, 0xb1, 0x3d, 0x88,
0xc2, 0x24, 0x24, 0xf6, 0xe0, 0x74, 0x7d, 0x71, 0x30, 0x3c, 0xf5, 0xbd, 0xae, 0x42, 0xe8, 0x23,
0xa8, 0x74, 0x82, 0x9e, 0x18, 0x1d, 0x88, 0x84, 0x13, 0x02, 0x85, 0xc7, 0x62, 0x1c, 0xbb, 0x4e,
0xc3, 0x6a, 0x96, 0x19, 0x7e, 0x93, 0x3b, 0xb0, 0x74, 0x1c, 0xf1, 0xee, 0xc5, 0xfe, 0xc8, 0x8b,
0x13, 0x11, 0x74, 0x85, 0x5b, 0x40, 0xee, 0x14, 0x4a, 0x7f, 0x76, 0x60, 0xf1, 0xa1, 0x27, 0xfc,
0xde, 0xb3, 0x41, 0xe2, 0x85, 0x41, 0x2c, 0x95, 0x1d, 0x8f, 0x07, 0xc2, 0x2d, 0x37, 0xac, 0x66,
0x85, 0xe1, 0x37, 0xb9, 0x0d, 0x95, 0x16, 0xef, 0x9e, 0x0b, 0x64, 0x38, 0xc8, 0xc8, 0x80, 0x94,
0x7b, 0xe4, 0xbd, 0x52, 0x56, 0x6a, 0x2c, 0x03, 0x48, 0x03, 0xaa, 0xc7, 0x5e, 0x5f, 0x3c, 0x1f,
0xf2, 0x20, 0x19, 0xf6, 0xdd, 0x22, 0xae, 0xce, 0x43, 0xe4, 0x26, 0x2c, 0x3c, 0xf3, 0x7b, 0x07,
0x5e, 0xe0, 0x56, 0x1a, 0x56, 0xd3, 0x61, 0x9a, 0x32, 0x38, 0x1f, 0xb9, 0x90, 0xe1, 0x7c, 0x94,
0x86, 0x5b, 0x9d, 0x0c, 0xf7, 0x69, 0x78, 0x94, 0xf0, 0xa0, 0xc7, 0xa3, 0xde, 0x89, 0x27, 0x5e,
0xba, 0x8b, 0x2a, 0xdc, 0x49, 0x54, 0xae, 0xdd, 0xe3, 0xb1, 0x70, 0x6b, 0xa8, 0x11, 0xbf, 0xc9,
0x3a, 0x94, 0xf7, 0xbc, 0xa4, 0x2d, 0x06, 0xc9, 0xb9, 0xbb, 0xd4, 0xb0, 0x9a, 0x05, 0x96, 0xd2,
0x64, 0x15, 0x8a, 0x47, 0x5d, 0xee, 0x0b, 0x77, 0x19, 0x17, 0x28, 0x82, 0x50, 0x58, 0x7c, 0x18,
0x46, 0xc2, 0x3b, 0x0b, 0x70, 0x13, 0xdc, 0x3a, 0x06, 0x35, 0x81, 0x91, 0xff, 0x82, 0x23, 0x43,
0x5a, 0x69, 0x58, 0xcd, 0xea, 0x4e, 0x75, 0x7b, 0x70, 0xba, 0xdd, 0x16, 0x5d, 0xaf, 0xcf, 0x7d,
0x26, 0x71, 0x64, 0xf3, 0x91, 0x4b, 0x66, 0xb1, 0xf9, 0x48, 0xfa, 0x24, 0x53, 0xf4, 0x22, 0xf0,
0x12, 0xf7, 0x06, 0x6a, 0x4f, 0x69, 0x52, 0x07, 0xe7, 0xf8, 0xf8, 0x89, 0xbb, 0x8a, 0xb0, 0xfc,
0xa4, 0x14, 0x96, 0x3a, 0xfd, 0x41, 0x18, 0x25, 0x4c, 0xc4, 0x83, 0x30, 0x88, 0x85, 0x94, 0xd9,
0x8f, 0x22, 0xd7, 0x52, 0x32, 0xfb, 0x51, 0x44, 0xbf, 0x80, 0xfa, 0x9e, 0x1f, 0x76, 0x2f, 0xda,
0x3c, 0xe1, 0x4c, 0x7c, 0x3e, 0x14, 0x71, 0x22, 0xa3, 0x53, 0x01, 0x28, 0x39, 0x45, 0x48, 0x14,
0x2b, 0xc2, 0xb5, 0x15, 0x8a, 0x84, 0xcc, 0x1c, 0xe6, 0x55, 0x6d, 0x20, 0x7e, 0x63, 0x76, 0xce,
0x79, 0xd4, 0xc3, 0x5d, 0x2f, 0x30, 0x45, 0x48, 0x14, 0x2d, 0x61, 0xa5, 0x14, 0x98, 0x22, 0x68,
0x07, 0x56, 0x72, 0xf6, 0xb5, 0x9b, 0x37, 0x61, 0x81, 0x85, 0x2f, 0x3b, 0xed, 0xd8, 0xb5, 0x1a,
0x4e, 0xb3, 0xc0, 0x34, 0x85, 0x25, 0x15, 0xfa, 0xc3, 0x7e, 0x20, 0x59, 0x36, 0xb2, 0x32, 0x80,
0xae, 0x41, 0x11, 0xeb, 0x4b, 0x46, 0x99, 0xad, 0x95, 0x9f, 0xf4, 0x4b, 0x0b, 0x2a, 0x07, 0x7c,
0x84, 0x8e, 0xc4, 0xe4, 0x3e, 0x94, 0xcd, 0xee, 0xa3, 0x50, 0x75, 0xe7, 0x96, 0xcc, 0x74, 0x2a,
0xb0, 0x6d, 0xb8, 0xfb, 0x41, 0x12, 0x8d, 0x59, 0x2a, 0xbc, 0xfe, 0x11, 0xd4, 0x26, 0x58, 0xd2,
0xd2, 0x85, 0x18, 0x9b, 0x7c, 0x5e, 0x88, 0xb1, 0x8c, 0xf2, 0x92, 0xfb, 0x43, 0x81, 0x59, 0x2a,
0x30, 0x45, 0x7c, 0x68, 0x7f, 0x60, 0xd1, 0x13, 0x20, 0xad, 0x48, 0xf0, 0x44, 0xa0, 0x91, 0x03,
0x11, 0xc7, 0xfc, 0x4c, 0xcc, 0xcb, 0xb5, 0x93, 0xcf, 0x75, 0x9a, 0x57, 0x3b, 0x97, 0x57, 0xba,
0x05, 0xa4, 0x2d, 0x7c, 0x91, 0x08, 0x7d, 0xf2, 0xdf, 0xa2, 0x97, 0x5e, 0x18, 0x1f, 0xe6, 0xcb,
0x92, 0x4d, 0x28, 0xc8, 0x36, 0x82, 0xc6, 0xaa, 0x3b, 0x35, 0x99, 0xa1, 0xb4, 0xb7, 0x30, 0x64,
0xe1, 0x7e, 0xa0, 0xba, 0xde, 0x6e, 0x82, 0xae, 0x3a, 0x2c, 0x03, 0xe8, 0xd7, 0x96, 0xb1, 0x86,
0xee, 0xff, 0xc5, 0x88, 0x27, 0xaa, 0xeb, 0xff, 0xda, 0x07, 0x07, 0x7d, 0xa8, 0x4b, 0x1f, 0xf2,
0x5d, 0x69, 0x96, 0x1b, 0x85, 0x69, 0x37, 0x1e, 0x98, 0xfc, 0x5c, 0xd7, 0x0b, 0xda, 0x85, 0x5b,
0x4a, 0xc3, 0xee, 0x25, 0xf7, 0x7c, 0x7e, 0xea, 0xff, 0xad, 0x2d, 0x9c, 0x08, 0xc8, 0x85, 0x12,
0xae, 0xed, 0xb4, 0xf5, 0x31, 0x30, 0x24, 0x1d, 0x42, 0x76, 0xa2, 0x9e, 0xf2, 0xbe, 0xd0, 0xda,
0xf0, 0x3b, 0xcd, 0x83, 0xfd, 0xd6, 0x3c, 0xac, 0x42, 0x51, 0x9e, 0x3f, 0xd9, 0xf1, 0x1d, 0x69,
0x12, 0x89, 0x39, 0xd9, 0x79, 0x17, 0x16, 0x8e, 0xba, 0xe7, 0xa2, 0xcf, 0xc9, 0xff, 0xa0, 0x84,
0x9e, 0x8b, 0x58, 0x1f, 0x8a, 0x4a, 0xba, 0xe5, 0xcc, 0x70, 0xe8, 0x37, 0x96, 0x0e, 0x76, 0xa6,
0x9b, 0x13, 0xa6, 0xec, 0x29, 0x53, 0xe4, 0x2e, 0x94, 0xb4, 0xbf, 0xd8, 0x2d, 0xde, 0xa8, 0x29,
0xc3, 0x25, 0x9b, 0xb0, 0x80, 0xd1, 0xc5, 0x6e, 0x21, 0x73, 0x04, 0x11, 0xa6, 0x19, 0x74, 0x1f,
0x9c, 0x17, 0xac, 0x23, 0x1b, 0x05, 0x7a, 0x6f, 0xdc, 0xd0, 0x94, 0x74, 0xee, 0xe3, 0x30, 0x4e,
0x74, 0xee, 0xf1, 0x5b, 0x62, 0x87, 0x61, 0xa4, 0xea, 0xb4, 0xc6, 0xf0, 0x9b, 0x7e, 0x67, 0x41,
0xe1, 0x69, 0xd8, 0x13, 0x64, 0x09, 0xec, 0x4e, 0x5b, 0x2b, 0xb1, 0x3b, 0x6d, 0xb2, 0x86, 0xfa,
0x75, 0xbe, 0x4b, 0xd2, 0xfe, 0x0b, 0xd6, 0x61, 0x68, 0xf3, 0x36, 0x54, 0x3a, 0xf1, 0x61, 0xe4,
0xf5, 0x79, 0x34, 0xd6, 0x77, 0x6b, 0x06, 0xe0, 0x19, 0x4d, 0x78, 0xa2, 0x6e, 0xbc, 0x0a, 0x53,
0x04, 0xd9, 0x84, 0xd2, 0x23, 0x76, 0xd8, 0x92, 0x2a, 0x8b, 0x93, 0x2a, 0x0d, 0x4e, 0x1f, 0x40,
0x5d, 0x7a, 0x82, 0xf2, 0xa6, 0xb2, 0x6e, 0xc2, 0x82, 0xc4, 0x52, 0xcf, 0x34, 0x95, 0x19, 0xb1,
0x73, 0x46, 0xe8, 0x43, 0xa5, 0x61, 0xff, 0x52, 0x04, 0x49, 0xae, 0x36, 0x91, 0x46, 0x05, 0x35,
0xa6, 0x08, 0x72, 0x5b, 0x45, 0xad, 0xc3, 0x2b, 0x4b, 0x5f, 0x24, 0xcd, 0x10, 0xa5, 0x63, 0x00,
0xe3, 0xc9, 0x30, 0x4e, 0x65, 0xad, 0x59, 0xb2, 0x84, 0x9a, 0xf2, 0xd1, 0x47, 0x14, 0x24, 0x5f,
0x21, 0xcc, 0x14, 0xd6, 0x3b, 0x59, 0x61, 0xa9, 0xfd, 0x5c, 0x4e, 0xf7, 0x5d, 0xd9, 0xc8, 0xca,
0xeb, 0x1c, 0xaa, 0x39, 0x7c, 0x66, 0x8d, 0xdd, 0x4d, 0x8b, 0xc3, 0xce, 0x94, 0x21, 0xa2, 0x95,
0x69, 0xf6, 0x9c, 0xe6, 0xe4, 0x41, 0x35, 0xb7, 0x68, 0xa6, 0xa5, 0x26, 0x2c, 0x4f, 0x1e, 0x78,
0x73, 0xe7, 0x4c, 0xc3, 0x73, 0x4c, 0x7d, 0x6b, 0x41, 0xad, 0xe5, 0x0f, 0xe3, 0x44, 0x44, 0x69,
0x4e, 0x2b, 0x1a, 0x48, 0xb7, 0x36, 0x03, 0x66, 0xef, 0x2e, 0xd9, 0x80, 0xa2, 0xcc, 0xb8, 0x3a,
0xdc, 0xf9, 0x8d, 0x50, 0x70, 0x6e, 0x27, 0x0a, 0x57, 0xed, 0x04, 0x3d, 0x81, 0xf2, 0xde, 0x51,
0xe7, 0x51, 0x14, 0x0e, 0x07, 0x33, 0x23, 0x36, 0x43, 0x9e, 0x9d, 0x1b, 0xf2, 0xea, 0x6a, 0x60,
0x51, 0x51, 0xe1, 0x8c, 0x52, 0x57, 0x33, 0x4a, 0x41, 0x23, 0x7c, 0x44, 0x8f, 0x60, 0x45, 0x85,
0x2b, 0x3b, 0xce, 0x75, 0xda, 0xa2, 0x99, 0x22, 0x9c, 0x6c, 0x8a, 0x90, 0x4a, 0x55, 0xd7, 0xfd,
0x27, 0x95, 0xfe, 0x6a, 0xc3, 0x0a, 0x13, 0xb1, 0xf7, 0x4a, 0x74, 0x82, 0x38, 0x89, 0x86, 0x5d,
0xd9, 0x71, 0xe4, 0xfa, 0x4f, 0xc2, 0x53, 0xbd, 0x17, 0x0e, 0x53, 0xc4, 0xdb, 0x4f, 0x09, 0xa1,
0x50, 0xca, 0x37, 0x81, 0xbc, 0x80, 0x61, 0x90, 0x2d, 0x28, 0x1d, 0x85, 0xc3, 0xa8, 0x9b, 0x56,
0x3e, 0x76, 0x6e, 0x65, 0x5f, 0x31, 0x98, 0x11, 0x20, 0x8f, 0x81, 0x1c, 0x47, 0x3c, 0x88, 0x7d,
0x2e, 0x5d, 0x32, 0xcb, 0xca, 0xd9, 0x78, 0x92, 0xe3, 0x4e, 0x68, 0x98, 0xb1, 0x8c, 0x6c, 0xe7,
0x8f, 0xb0, 0x5b, 0x42, 0xff, 0x96, 0x8c, 0x7f, 0xfa, 0x9c, 0xe4, 0x0f, 0xf9, 0xfd, 0xa9, 0x0a,
0x75, 0x17, 0x70, 0xc9, 0x8a, 0x5c, 0x32, 0xc1, 0x60, 0x93, 0x72, 0xf4, 0x2b, 0x0b, 0x16, 0xf3,
0xde, 0xcc, 0x69, 0x17, 0xe9, 0xf6, 0xd9, 0xf3, 0xa7, 0x1d, 0xb3, 0x7d, 0x85, 0x59, 0x93, 0x65,
0x31, 0x3f, 0x01, 0x85, 0xf0, 0x9f, 0x2b, 0x92, 0x73, 0x2d, 0x77, 0x1a, 0x50, 0x3d, 0xe4, 0x51,
0xe2, 0x49, 0x65, 0xfa, 0x9e, 0x2e, 0xb2, 0x3c, 0x44, 0x05, 0xac, 0xbd, 0x51, 0x44, 0xad, 0xb0,
0x3f, 0x90, 0xd5, 0x7a, 0xad, 0x62, 0x92, 0x6d, 0x3a, 0x8a, 0xc2, 0xc8, 0x64, 0x00, 0x09, 0xba,
0x07, 0xe5, 0xe3, 0x70, 0x10, 0xfa, 0xe1, 0xd9, 0x78, 0x4e, 0xcb, 0x70, 0xa1, 0xa4, 0xae, 0x06,
0xd5, 0xa2, 0x2a, 0xcc, 0x90, 0xf4, 0x86, 0xac, 0xf7, 0x2e, 0xf7, 0xbb, 0x43, 0x9f, 0x27, 0x02,
0xe7, 0x63, 0x04, 0x9f, 0x84, 0xbc, 0xa7, 0xba, 0x82, 0x3e, 0x5a, 0xf4, 0x33, 0x5d, 0x80, 0x1c,
0xc3, 0xc9, 0x5d, 0x41, 0xbb, 0x08, 0x98, 0x2b, 0x48, 0x51, 0xe4, 0x7d, 0xa8, 0xe6, 0xa4, 0x75,
0x58, 0xcb, 0x69, 0x9d, 0x2a, 0x98, 0xe5, 0x65, 0xe8, 0x4f, 0xd6, 0xc4, 0x9a, 0x37, 0xee, 0x5c,
0x6d, 0xea, 0x52, 0x25, 0xa9, 0xcc, 0x34, 0x25, 0x43, 0xdf, 0x1f, 0x75, 0xfd, 0x61, 0x2c, 0x59,
0xfa, 0xc2, 0x4d, 0x01, 0x19, 0xba, 0x7c, 0x02, 0x85, 0x43, 0x33, 0xdc, 0x18, 0x52, 0x3e, 0x96,
0xda, 0x82, 0xf7, 0x7c, 0x2f, 0x10, 0x58, 0x2f, 0x0e, 0x4b, 0x69, 0xb2, 0xa5, 0x7a, 0xac, 0x29,
0xf4, 0xd5, 0x29, 0xc7, 0x91, 0xa7, 0x3a, 0x6f, 0x4c, 0x09, 0xd4, 0xa7, 0x59, 0x74, 0x15, 0x88,
0xaa, 0x80, 0xdd, 0xd3, 0x30, 0x32, 0xb7, 0x2d, 0x6d, 0x99, 0xe6, 0x22, 0xb3, 0x3f, 0xef, 0x12,
0xcf, 0x32, 0x6b, 0xe7, 0x33, 0x4b, 0x3f, 0x85, 0x25, 0x3d, 0xdb, 0x89, 0x08, 0x0b, 0x5a, 0x26,
0x80, 0x89, 0x6e, 0x28, 0xc7, 0x44, 0xf3, 0xaa, 0xc9, 0x00, 0xa9, 0xe7, 0x44, 0x3e, 0x32, 0xcc,
0xed, 0xa4, 0x29, 0x9c, 0x8d, 0xbc, 0xb3, 0x40, 0xf4, 0xf0, 0xc6, 0x70, 0x98, 0xa6, 0xe8, 0xf7,
0x36, 0xac, 0xaa, 0xa1, 0x33, 0x38, 0x13, 0x71, 0x92, 0x99, 0x91, 0x0f, 0xeb, 0x01, 0xf6, 0x7f,
0xed, 0xa8, 0xa2, 0xe4, 0x23, 0xba, 0xe5, 0x0b, 0x1e, 0x65, 0x3e, 0x28, 0x43, 0x53, 0xa8, 0x3c,
0x37, 0x88, 0xe8, 0xeb, 0x59, 0x0d, 0xa1, 0x79, 0x88, 0xec, 0x41, 0x59, 0x87, 0x66, 0x1a, 0xe2,
0x1d, 0xbc, 0xa5, 0x66, 0x78, 0x63, 0xe6, 0xdb, 0x58, 0xbf, 0xc1, 0x0c, 0xb9, 0xfe, 0x0c, 0x6a,
0x13, 0xac, 0x19, 0x6f, 0xb0, 0x66, 0xfe, 0x0d, 0x56, 0xdd, 0x21, 0xb9, 0x71, 0x59, 0x6b, 0xcf,
0xbf, 0xcb, 0x5a, 0xf0, 0xef, 0x59, 0x0e, 0xc4, 0x64, 0x0b, 0x1c, 0xe9, 0xa8, 0x1a, 0x86, 0xdd,
0xab, 0x1c, 0x65, 0x52, 0x88, 0xfe, 0x68, 0xe9, 0xa4, 0x0a, 0xcd, 0x37, 0x6f, 0xe9, 0x7b, 0x79,
0x25, 0x9b, 0xa9, 0x92, 0x29, 0xb1, 0xed, 0x34, 0x50, 0x29, 0xbd, 0xfe, 0x1c, 0xca, 0xb3, 0xc2,
0x2b, 0xa8, 0xf0, 0xde, 0x9b, 0x0c, 0x6f, 0xed, 0x2a, 0xcf, 0xe2, 0x5c, 0x94, 0x7b, 0xf5, 0x5f,
0x5e, 0x6f, 0x58, 0xbf, 0xbd, 0xde, 0xb0, 0x7e, 0x7f, 0xbd, 0x61, 0xfd, 0xf0, 0xc7, 0xc6, 0xbf,
0x4e, 0x17, 0xf0, 0x97, 0xd1, 0xbd, 0x3f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xd0, 0x83, 0x3d, 0x4c,
0x55, 0x12, 0x00, 0x00,
}
func (m *IndexMeta) Marshal() (dAtA []byte, err error) {
@ -2945,10 +2945,10 @@ func (m *FieldOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Ttl) > 0 {
i -= len(m.Ttl)
copy(dAtA[i:], m.Ttl)
i = encodeVarintPrivate(dAtA, i, uint64(len(m.Ttl)))
if len(m.TTL) > 0 {
i -= len(m.TTL)
copy(dAtA[i:], m.TTL)
i = encodeVarintPrivate(dAtA, i, uint64(len(m.TTL)))
i--
dAtA[i] = 0x1
i--
@ -5292,7 +5292,7 @@ func (m *FieldOptions) Size() (n int) {
if l > 0 {
n += 2 + l + sovPrivate(uint64(l))
}
l = len(m.Ttl)
l = len(m.TTL)
if l > 0 {
n += 2 + l + sovPrivate(uint64(l))
}
@ -6356,7 +6356,10 @@ func (m *IndexMeta) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -6789,7 +6792,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
iNdEx = postIndex
case 20:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Ttl", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
@ -6817,7 +6820,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Ttl = string(dAtA[iNdEx:postIndex])
m.TTL = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
@ -6825,7 +6828,10 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -6908,7 +6914,10 @@ func (m *ImportResponse) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -7093,7 +7102,10 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -7296,7 +7308,10 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -7423,7 +7438,10 @@ func (m *Cache) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -7570,7 +7588,7 @@ func (m *MaxShards) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > postIndex {
@ -7587,7 +7605,10 @@ func (m *MaxShards) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -7721,7 +7742,10 @@ func (m *CreateShardMessage) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -7804,7 +7828,10 @@ func (m *DeleteIndexMessage) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -7942,7 +7969,10 @@ func (m *CreateIndexMessage) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -8112,7 +8142,10 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -8227,7 +8260,10 @@ func (m *DeleteFieldMessage) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -8361,7 +8397,10 @@ func (m *DeleteAvailableShardMessage) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -8531,7 +8570,10 @@ func (m *Field) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -8616,7 +8658,10 @@ func (m *Schema) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -8788,7 +8833,10 @@ func (m *Index) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -8922,7 +8970,10 @@ func (m *URI) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -9129,7 +9180,10 @@ func (m *Node) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -9244,7 +9298,10 @@ func (m *NodeStateMessage) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -9350,7 +9407,10 @@ func (m *NodeEventMessage) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -9507,7 +9567,10 @@ func (m *NodeStatus) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -9643,7 +9706,10 @@ func (m *IndexStatus) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -9821,7 +9887,10 @@ func (m *FieldStatus) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -10006,7 +10075,10 @@ func (m *ClusterStatus) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -10159,7 +10231,10 @@ func (m *BSIGroup) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -10306,7 +10381,10 @@ func (m *CreateViewMessage) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -10453,7 +10531,10 @@ func (m *DeleteViewMessage) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -10735,7 +10816,10 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -10937,7 +11021,10 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -11075,7 +11162,10 @@ func (m *TranslationResizeSource) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -11213,7 +11303,10 @@ func (m *ResizeInstructionComplete) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -11328,7 +11421,10 @@ func (m *Topology) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -11379,7 +11475,10 @@ func (m *RecalculateCaches) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -11430,7 +11529,10 @@ func (m *LoadSchemaMessage) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -11549,7 +11651,10 @@ func (m *TransactionMessage) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -11746,7 +11851,10 @@ func (m *Transaction) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -11797,7 +11905,10 @@ func (m *TransactionStats) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -11848,7 +11959,10 @@ func (m *ResizeAbortMessage) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -11963,7 +12077,10 @@ func (m *ResizeNodeMessage) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -12242,7 +12359,10 @@ func (m *FieldOperation) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -12545,7 +12665,7 @@ func (m *ShardIngestOperation) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > postIndex {
@ -12562,7 +12682,10 @@ func (m *ShardIngestOperation) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -12647,7 +12770,10 @@ func (m *ShardIngestOperations) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
@ -12796,7 +12922,7 @@ func (m *ShardedIngestRequest) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > postIndex {
@ -12813,7 +12939,10 @@ func (m *ShardedIngestRequest) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {

2
pb/private.proto
View file

@ -25,7 +25,7 @@ message FieldOptions {
Decimal Min = 17;
Decimal Max = 18;
string TimeUnit = 19;
string Ttl = 20;
string TTL = 20;
}
message ImportResponse {

175
pb/public.pb.go
View file

@ -6149,7 +6149,10 @@ func (m *Row) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -6234,7 +6237,10 @@ func (m *RowMatrix) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -6357,7 +6363,10 @@ func (m *SignedRow) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -6516,7 +6525,10 @@ func (m *RowIdentifiers) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -6643,7 +6655,10 @@ func (m *IDList) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -6747,7 +6762,10 @@ func (m *ExtractedIDColumn) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -6864,7 +6882,10 @@ func (m *ExtractedIDMatrix) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -6947,7 +6968,10 @@ func (m *KeyList) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -7161,7 +7185,10 @@ func (m *ExtractedTableValue) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -7298,7 +7325,10 @@ func (m *ExtractedTableColumn) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -7413,7 +7443,10 @@ func (m *ExtractedTableField) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -7532,7 +7565,10 @@ func (m *ExtractedTable) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -7653,7 +7689,10 @@ func (m *Pair) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -7772,7 +7811,10 @@ func (m *PairField) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -7889,7 +7931,10 @@ func (m *PairsField) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -7959,7 +8004,10 @@ func (m *Int64) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -8129,7 +8177,10 @@ func (m *FieldRow) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -8252,7 +8303,10 @@ func (m *GroupCount) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -8420,7 +8474,10 @@ func (m *ValCount) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -8509,7 +8566,10 @@ func (m *Decimal) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -8624,7 +8684,10 @@ func (m *DistinctTimestamp) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -8876,7 +8939,10 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -8993,7 +9059,10 @@ func (m *QueryResponse) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -9642,7 +9711,10 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -10126,7 +10198,10 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -10588,7 +10663,10 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -10758,7 +10836,10 @@ func (m *AtomicRecord) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -10841,7 +10922,10 @@ func (m *AtomicImportResponse) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -11008,7 +11092,10 @@ func (m *TranslateKeysRequest) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -11135,7 +11222,10 @@ func (m *TranslateKeysResponse) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -11326,7 +11416,10 @@ func (m *TranslateIDsRequest) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -11409,7 +11502,10 @@ func (m *TranslateIDsResponse) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -11526,7 +11622,10 @@ func (m *ImportRoaringRequestView) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -11740,7 +11839,10 @@ func (m *ImportRoaringRequest) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
@ -11857,7 +11959,10 @@ func (m *GroupCounts) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {

20
server.go
View file

@ -168,9 +168,9 @@ func OptServerAntiEntropyInterval(interval time.Duration) ServerOption {
}
}
// OptServerTtlRemovalInterval is a functional option on Server
// OptServerTTLRemovalInterval is a functional option on Server
// used to set the ttl removal interval.
func OptServerTtlRemovalInterval(interval time.Duration) ServerOption {
func OptServerTTLRemovalInterval(interval time.Duration) ServerOption {
return func(s *Server) error {
s.ttlRemovalInterval = interval
return nil
@ -658,7 +658,7 @@ func (s *Server) Open() error {
go func() { defer s.wg.Done(); s.monitorAntiEntropy() }()
go func() { defer s.wg.Done(); s.monitorRuntime() }()
go func() { defer s.wg.Done(); s.monitorDiagnostics() }()
go func() { defer s.wg.Done(); s.monitorTtl() }()
go func() { defer s.wg.Done(); s.monitorTTL() }()
toSend := func() []Message {
s.holder.startMsgsMu.Lock()
@ -842,26 +842,26 @@ func (s *Server) monitorResetTranslationSync() {
}
}
func (s *Server) monitorTtl() {
func (s *Server) monitorTTL() {
ctx := context.Background()
// Run TtlRemoval on server start
s.TtlRemoval(ctx)
// Run TTLRemoval on server start
s.TTLRemoval(ctx)
ticker := time.NewTicker(s.ttlRemovalInterval)
for {
select {
case <-s.closing:
return
case <-ticker.C:
s.TtlRemoval(ctx)
s.TTLRemoval(ctx)
}
}
}
func (s *Server) TtlRemoval(ctx context.Context) {
func (s *Server) TTLRemoval(ctx context.Context) {
for _, index := range s.holder.Indexes() {
for _, field := range index.Fields() {
if field.Options().Type == "time" {
if field.Options().Ttl > 0 {
if field.Options().TTL > 0 {
for _, view := range field.views() {
viewNames := strings.Split(view.name, "_")
if len(viewNames) >= 2 {
@ -872,7 +872,7 @@ func (s *Server) TtlRemoval(ctx context.Context) {
}
timeSince := time.Since(viewTime)
if timeSince >= field.Options().Ttl {
if timeSince >= field.Options().TTL {
for _, shard := range field.AvailableShards(true).Slice() {
s.holder.txf.DeleteFragmentFromStore(index.Name(), field.Name(), view.name, shard, nil)
}

6
server_test.go
View file

@ -13,7 +13,7 @@ import (
"github.com/molecula/featurebase/v3/test"
)
func TestTtlRemoval(t *testing.T) {
func TestTTLRemoval(t *testing.T) {
cluster := test.MustRunCluster(t, 1)
node := cluster.GetNode(0)
@ -28,7 +28,7 @@ func TestTtlRemoval(t *testing.T) {
// Create indexes and field with ttl lasting 24 hours
if err := client.CreateIndex(context.Background(), indexName, pilosa.IndexOptions{TrackExistence: true}); err != nil && err != pilosa.ErrIndexExists {
t.Fatalf("creating index, err: %v", err)
} else if err := client.CreateFieldWithOptions(context.Background(), indexName, fieldName, pilosa.FieldOptions{Ttl: time.Hour * 24, Type: pilosa.FieldTypeTime, TimeQuantum: "YMDH"}); err != nil {
} else if err := client.CreateFieldWithOptions(context.Background(), indexName, fieldName, pilosa.FieldOptions{TTL: time.Hour * 24, Type: pilosa.FieldTypeTime, TimeQuantum: "YMDH"}); err != nil {
t.Fatalf("creating field, err: %v", err)
}
@ -69,7 +69,7 @@ func TestTtlRemoval(t *testing.T) {
t.Fatalf("setting sample data 3, err: %v", err)
}
node.Server.TtlRemoval(context.Background())
node.Server.TTLRemoval(context.Background())
// Get all the views for given index + field
views, err := node.API.Views(context.Background(), indexName, fieldName)